name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
void storeA2RGB30PMFromARGB32PM_sse4<(QtPixelOrder)0>(unsigned char*, unsigned int const*, int, int, QList<unsigned int> const*, QDitherInfo*) | void QT_FASTCALL storeA2RGB30PMFromARGB32PM_sse4(uchar *dest, const uint *src, int index, int count,
const QList<QRgb> *, QDitherInfo *)
{
uint *d = reinterpret_cast<uint *>(dest) + index;
for (int i = 0; i < count; ++i)
d[i] = qConvertArgb32ToA2rgb30_sse4<PixelOrder>(src[i]);
} | endbr64
testl %ecx, %ecx
jle 0x4ad425
pushq %rbx
movslq %edx, %rax
leaq (%rdi,%rax,4), %rax
movl %ecx, %ecx
xorl %edx, %edx
movl (%rsi,%rdx,4), %edi
movl %edi, %r8d
shrl $0x18, %r8d
je 0x4ad414
cmpl $0xff, %r8d
jne 0x4ad398
movl %edi, %r8d
shll $0x6, %r8d
andl $0x3fc00000, %r8d # imm = 0x3FC00000
movl %edi, %r9d
shrl $0x2, %r9d
andl $0x300000, %r9d # imm = 0x300000
movl %edi, %r10d
shll $0x4, %r10d
andl $0xff000, %r10d # imm = 0xFF000
movl %edi, %r11d
shrl $0x4, %r11d
andl $0xc00, %r11d # imm = 0xC00
movzbl %dil, %ebx
shrl $0x6, %edi
andl $0x3, %edi
leal (%rdi,%rbx,4), %edi
orl %r9d, %edi
orl %r8d, %edi
orl %r11d, %edi
leal (%r10,%rdi), %r8d
addl $0xc0000000, %r8d # imm = 0xC0000000
jmp 0x4ad414
movl %edi, %r9d
shrl $0x1e, %r9d
xorps %xmm0, %xmm0
cvtsi2ss %r8d, %xmm0
imull $0x155, %r9d, %r8d # imm = 0x155
xorps %xmm1, %xmm1
cvtsi2ss %r8d, %xmm1
movaps %xmm0, %xmm2
rcpss %xmm0, %xmm2
mulss %xmm2, %xmm0
mulss %xmm2, %xmm0
addss %xmm2, %xmm2
subss %xmm0, %xmm2
mulss %xmm1, %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
movd %edi, %xmm0
pmovzxbd %xmm0, %xmm0 # xmm0 = xmm0[0],zero,zero,zero,xmm0[1],zero,zero,zero,xmm0[2],zero,zero,zero,xmm0[3],zero,zero,zero
cvtdq2ps %xmm0, %xmm0
mulps %xmm2, %xmm0
cvtps2dq %xmm0, %xmm0
packusdw %xmm0, %xmm0
andl $0xc0000000, %edi # imm = 0xC0000000
pextrw $0x1, %xmm0, %r9d
shll $0xa, %r9d
orl %edi, %r9d
pextrw $0x2, %xmm0, %edi
shll $0x14, %edi
pextrw $0x0, %xmm0, %r8d
orl %edi, %r8d
orl %r9d, %r8d
movl %r8d, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x4ad324
popq %rbx
retq
nop
| /qt[P]qtbase/src/gui/painting/qdrawhelper_sse4.cpp |
void qt_qimageScaleAARGBA_up_x_down_y_sse4<false>(QImageScale::QImageScaleInfo*, unsigned int*, int, int, int, int) | void qt_qimageScaleAARGBA_up_x_down_y_sse4(QImageScaleInfo *isi, unsigned int *dest,
int dw, int dh, int dow, int sow)
{
const unsigned int **ypoints = isi->ypoints;
const int *xpoints = isi->xpoints;
const int *xapoints = isi->xapoints;
const int *yapoints = isi->yapoints;
const __m128i v256 = _mm_set1_epi32(256);
/* go through every scanline in the output buffer */
auto scaleSection = [&] (int yStart, int yEnd) {
for (int y = yStart; y < yEnd; ++y) {
const int Cy = yapoints[y] >> 16;
const int yap = yapoints[y] & 0xffff;
const __m128i vCy = _mm_set1_epi32(Cy);
const __m128i vyap = _mm_set1_epi32(yap);
unsigned int *dptr = dest + (y * dow);
for (int x = 0; x < dw; x++) {
const unsigned int *sptr = ypoints[y] + xpoints[x];
__m128i vx = qt_qimageScaleAARGBA_helper(sptr, yap, Cy, sow, vyap, vCy);
const int xap = xapoints[x];
if (xap > 0) {
const __m128i vxap = _mm_set1_epi32(xap);
const __m128i vinvxap = _mm_sub_epi32(v256, vxap);
__m128i vr = qt_qimageScaleAARGBA_helper(sptr + 1, yap, Cy, sow, vyap, vCy);
vx = _mm_mullo_epi32(vx, vinvxap);
vr = _mm_mullo_epi32(vr, vxap);
vx = _mm_add_epi32(vx, vr);
vx = _mm_srli_epi32(vx, 8);
}
vx = _mm_srli_epi32(vx, 14);
vx = _mm_packus_epi32(vx, vx);
vx = _mm_packus_epi16(vx, vx);
*dptr = _mm_cvtsi128_si32(vx);
if (RGB)
*dptr |= 0xff000000;
dptr++;
}
}
};
multithread_pixels_function(isi, dh, scaleSection);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %ecx, %r15d
movq %fs:0x28, %rax
movq %rax, 0xb0(%rsp)
leaq 0xa0(%rsp), %rax
movq %rsi, (%rax)
leaq 0x9c(%rsp), %rcx
movl %edx, (%rcx)
leaq 0x98(%rsp), %rdx
movl %r8d, (%rdx)
leaq 0x94(%rsp), %rsi
movl %r9d, (%rsi)
movq 0x8(%rdi), %r8
leaq 0x88(%rsp), %r9
movq %r8, (%r9)
movq (%rdi), %r8
leaq 0x80(%rsp), %r10
movq %r8, (%r10)
movq 0x10(%rdi), %r8
leaq 0x78(%rsp), %r11
movq %r8, (%r11)
movq 0x18(%rdi), %r8
leaq 0x70(%rsp), %rbx
movq %r8, (%rbx)
pmovsxwd 0x11060d(%rip), %xmm0 # 0x5be760
leaq 0x60(%rsp), %r8
movdqa %xmm0, (%r8)
movq %rbx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
movq %r9, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rsi, 0x48(%rsp)
movq %r11, 0x50(%rsp)
movq %r8, 0x58(%rsp)
movslq 0x24(%rdi), %rax
movslq 0x28(%rdi), %rcx
imulq %rax, %rcx
leaq 0xffff(%rcx), %r14
testq %rcx, %rcx
cmovnsq %rcx, %r14
shrq $0x10, %r14
cmpl %r15d, %r14d
cmovgel %r15d, %r14d
callq 0x138da0
testq %rax, %rax
je 0x4ae1da
cmpl $0x2, %r14d
jl 0x4ae1da
movq %rax, %rbx
callq 0x141020
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13c2a0
testb %al, %al
je 0x4ae3a5
testl %r15d, %r15d
jle 0x4ae461
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl %r15d, %edx
movl 0x9c(%rsp), %eax
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %r8
xorl %r9d, %r9d
testl %eax, %eax
jle 0x4ae394
movq 0x10(%rsp), %rax
movl (%rax,%r9,4), %r10d
movzwl %r10w, %eax
movd %r10d, %xmm0
sarl $0x10, %r10d
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
psrad $0x10, %xmm0
movd %eax, %xmm1
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
movslq 0x98(%rsp), %rcx
imulq %r9, %rcx
movq 0x8(%rsp), %r11
leaq (%r11,%rcx,4), %r11
movq (%rsi,%r9,8), %rbx
movl $0x4000, %ebp # imm = 0x4000
subl %eax, %ebp
xorl %r14d, %r14d
movslq (%rdi,%r14,4), %rax
leaq (%rbx,%rax,4), %r12
movslq 0x94(%rsp), %r15
pmovzxbd (%r12), %xmm3
pmulld %xmm1, %xmm3
cmpl %r10d, %ebp
jle 0x4ae2ba
leaq (,%r15,4), %rcx
movq %r12, %rax
movl %ebp, %r13d
pmovzxbd (%rax,%rcx), %xmm2
addq %rcx, %rax
pmaddwd %xmm0, %xmm2
paddd %xmm2, %xmm3
subl %r10d, %r13d
cmpl %r10d, %r13d
jg 0x4ae29f
jmp 0x4ae2c0
movq %r12, %rax
movl %ebp, %r13d
pmovzxbd (%rax,%r15,4), %xmm4
movd %r13d, %xmm2
pshufd $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
pmulld %xmm4, %xmm2
paddd %xmm3, %xmm2
movl (%r8,%r14,4), %eax
testl %eax, %eax
jle 0x4ae369
leaq 0x4(%r12), %r13
pmovzxbd 0x4(%r12), %xmm3
pmulld %xmm1, %xmm3
cmpl %r10d, %ebp
jle 0x4ae325
leaq (,%r15,4), %rcx
movl %ebp, %r12d
pmovzxbd (%r13,%rcx), %xmm4
addq %rcx, %r13
pmaddwd %xmm0, %xmm4
paddd %xmm4, %xmm3
subl %r10d, %r12d
cmpl %r10d, %r12d
jg 0x4ae308
jmp 0x4ae328
movl %ebp, %r12d
movd %eax, %xmm4
pshufd $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
movdqa 0x60(%rsp), %xmm5
psubd %xmm4, %xmm5
pmovzxbd (%r13,%r15,4), %xmm6
movd %r12d, %xmm7
pmulld %xmm2, %xmm5
pshufd $0x0, %xmm7, %xmm2 # xmm2 = xmm7[0,0,0,0]
pmulld %xmm6, %xmm2
paddd %xmm3, %xmm2
pmulld %xmm4, %xmm2
paddd %xmm5, %xmm2
psrld $0x8, %xmm2
psrld $0xe, %xmm2
packusdw %xmm2, %xmm2
packuswb %xmm2, %xmm2
movd %xmm2, (%r11)
addq $0x4, %r11
incq %r14
movslq 0x9c(%rsp), %rax
cmpq %rax, %r14
jl 0x4ae270
incq %r9
cmpq %rdx, %r9
jne 0x4ae21c
jmp 0x4ae461
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0xa8(%rsp), %rdi
movq %rax, (%rdi)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x13c9f0
movq %rbx, 0x10(%rsp)
movq 0x240cf0(%rip), %rbx # 0x6ef0c0
addq $0x10, %rbx
movq %r14, 0x8(%rsp)
movl %r15d, %eax
subl %r12d, %eax
cltd
idivl %r14d
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r13
movb $0x1, 0x8(%rax)
movq %rbx, (%rax)
movl $0x20, %edi
callq 0x1387d0
leaq -0xfe2(%rip), %rcx # 0x4ad428
movq %rcx, (%rax)
movl %r12d, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0xa8(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x1393d0
addl %ebp, %r12d
decl %r14d
jne 0x4ae3d9
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x143df0
movq %rbx, %rdi
callq 0x13f120
movq %fs:0x28, %rax
cmpq 0xb0(%rsp), %rax
jne 0x4ae486
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qimagescale_sse4.cpp |
void qt_qimageScaleAARGBA_down_xy_sse4<false>(QImageScale::QImageScaleInfo*, unsigned int*, int, int, int, int) | void qt_qimageScaleAARGBA_down_xy_sse4(QImageScaleInfo *isi, unsigned int *dest,
int dw, int dh, int dow, int sow)
{
const unsigned int **ypoints = isi->ypoints;
int *xpoints = isi->xpoints;
int *xapoints = isi->xapoints;
int *yapoints = isi->yapoints;
auto scaleSection = [&] (int yStart, int yEnd) {
for (int y = yStart; y < yEnd; ++y) {
int Cy = yapoints[y] >> 16;
int yap = yapoints[y] & 0xffff;
const __m128i vCy = _mm_set1_epi32(Cy);
const __m128i vyap = _mm_set1_epi32(yap);
unsigned int *dptr = dest + (y * dow);
for (int x = 0; x < dw; x++) {
const int Cx = xapoints[x] >> 16;
const int xap = xapoints[x] & 0xffff;
const __m128i vCx = _mm_set1_epi32(Cx);
const __m128i vxap = _mm_set1_epi32(xap);
const unsigned int *sptr = ypoints[y] + xpoints[x];
__m128i vx = qt_qimageScaleAARGBA_helper(sptr, xap, Cx, 1, vxap, vCx);
__m128i vr = _mm_mullo_epi32(_mm_srli_epi32(vx, 4), vyap);
int j;
for (j = (1 << 14) - yap; j > Cy; j -= Cy) {
sptr += sow;
vx = qt_qimageScaleAARGBA_helper(sptr, xap, Cx, 1, vxap, vCx);
vr = _mm_add_epi32(vr, _mm_mullo_epi32(_mm_srli_epi32(vx, 4), vCy));
}
sptr += sow;
vx = qt_qimageScaleAARGBA_helper(sptr, xap, Cx, 1, vxap, vCx);
vr = _mm_add_epi32(vr, _mm_mullo_epi32(_mm_srli_epi32(vx, 4), _mm_set1_epi32(j)));
vr = _mm_srli_epi32(vr, 24);
vr = _mm_packus_epi32(vr, _mm_setzero_si128());
vr = _mm_packus_epi16(vr, _mm_setzero_si128());
*dptr = _mm_cvtsi128_si32(vr);
if (RGB)
*dptr |= 0xff000000;
dptr++;
}
}
};
multithread_pixels_function(isi, dh, scaleSection);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %r15d
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
leaq 0x90(%rsp), %rax
movq %rsi, (%rax)
leaq 0x8c(%rsp), %rcx
movl %edx, (%rcx)
leaq 0x88(%rsp), %rdx
movl %r8d, (%rdx)
leaq 0x84(%rsp), %rsi
movl %r9d, (%rsi)
movq 0x8(%rdi), %r8
leaq 0x78(%rsp), %r9
movq %r8, (%r9)
movq (%rdi), %r8
leaq 0x70(%rsp), %r10
movq %r8, (%r10)
movq 0x10(%rdi), %r8
leaq 0x68(%rsp), %r11
movq %r8, (%r11)
movq 0x18(%rdi), %r8
leaq 0x60(%rsp), %rbx
movq %r8, (%rbx)
movq %rbx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r11, 0x40(%rsp)
movq %r9, 0x48(%rsp)
movq %r10, 0x50(%rsp)
movq %rsi, 0x58(%rsp)
movslq 0x24(%rdi), %rax
movslq 0x28(%rdi), %rcx
imulq %rax, %rcx
leaq 0xffff(%rcx), %r14
testq %rcx, %rcx
cmovnsq %rcx, %r14
shrq $0x10, %r14
cmpl %r15d, %r14d
cmovgel %r15d, %r14d
callq 0x138da0
testq %rax, %rax
je 0x4af08f
cmpl $0x2, %r14d
jl 0x4af08f
movq %rax, %rbx
callq 0x141020
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13c2a0
testb %al, %al
je 0x4af2cd
testl %r15d, %r15d
jle 0x4af387
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movl %r15d, %eax
movq %rax, 0x8(%rsp)
movl 0x8c(%rsp), %ecx
movq 0x68(%rsp), %rsi
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %r8
xorl %r9d, %r9d
movd 0x10f664(%rip), %xmm0 # 0x5be740
testl %ecx, %ecx
jle 0x4af2ba
movq (%rsp), %rax
movl (%rax,%r9,4), %r10d
movzwl %r10w, %ecx
movd %r10d, %xmm1
sarl $0x10, %r10d
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
psrad $0x10, %xmm1
movd %ecx, %xmm2
pshufd $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
movslq 0x88(%rsp), %rax
imulq %r9, %rax
movq 0x18(%rsp), %rdx
leaq (%rdx,%rax,4), %r11
movq 0x10(%rsp), %rax
movq (%rax,%r9,8), %rbx
movl $0x4000, %eax # imm = 0x4000
subl %ecx, %eax
xorl %r14d, %r14d
movl (%rsi,%r14,4), %r15d
movzwl %r15w, %ecx
movd %r15d, %xmm3
sarl $0x10, %r15d
pshufd $0x0, %xmm3, %xmm4 # xmm4 = xmm3[0,0,0,0]
psrad $0x10, %xmm4
movd %ecx, %xmm3
pshufd $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
movslq (%r8,%r14,4), %rdx
leaq (%rbx,%rdx,4), %rdx
pmovzxbd (%rdx), %xmm6
pmulld %xmm3, %xmm6
movl $0x4000, %edi # imm = 0x4000
subl %ecx, %edi
cmpl %r15d, %edi
jle 0x4af197
movl %edi, %ecx
movq %rdx, %rbp
pmovzxbd 0x4(%rbp), %xmm5
addq $0x4, %rbp
pmaddwd %xmm4, %xmm5
paddd %xmm5, %xmm6
subl %r15d, %ecx
cmpl %r15d, %ecx
jg 0x4af17b
jmp 0x4af19c
movq %rdx, %rbp
movl %edi, %ecx
pmovzxbd 0x4(%rbp), %xmm7
movd %ecx, %xmm5
pshufd $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
pmulld %xmm7, %xmm5
paddd %xmm6, %xmm5
psrld $0x4, %xmm5
pmulld %xmm2, %xmm5
movslq 0x84(%rsp), %rcx
movl %eax, %ebp
cmpl %r10d, %eax
jle 0x4af23f
leaq (%rdx,%rcx,4), %rdx
pmovzxbd (%rdx), %xmm6
pmulld %xmm3, %xmm6
cmpl %r15d, %edi
jle 0x4af203
movl %edi, %r12d
movq %rdx, %r13
pmovzxbd 0x4(%r13), %xmm7
addq $0x4, %r13
pmaddwd %xmm4, %xmm7
paddd %xmm7, %xmm6
subl %r15d, %r12d
cmpl %r15d, %r12d
jg 0x4af1e6
jmp 0x4af209
movq %rdx, %r13
movl %edi, %r12d
pmovzxbd 0x4(%r13), %xmm7
movd %r12d, %xmm8
pshufd $0x0, %xmm8, %xmm8 # xmm8 = xmm8[0,0,0,0]
pmulld %xmm7, %xmm8
paddd %xmm6, %xmm8
psrld $0x4, %xmm8
pmulld %xmm1, %xmm8
paddd %xmm8, %xmm5
subl %r10d, %ebp
cmpl %r10d, %ebp
jg 0x4af1cd
leaq (%rdx,%rcx,4), %rcx
pmovzxbd (%rcx), %xmm6
pmulld %xmm6, %xmm3
cmpl %r15d, %edi
jle 0x4af269
pmovzxbd 0x4(%rcx), %xmm6
addq $0x4, %rcx
pmaddwd %xmm4, %xmm6
paddd %xmm6, %xmm3
subl %r15d, %edi
jmp 0x4af24d
pmovzxbd 0x4(%rcx), %xmm4
movd %edi, %xmm6
pshufd $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
pmulld %xmm4, %xmm6
paddd %xmm3, %xmm6
psrld $0x4, %xmm6
movd %ebp, %xmm3
pshufd $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
pmulld %xmm6, %xmm3
paddd %xmm5, %xmm3
pshufb %xmm0, %xmm3
movd %xmm3, (%r11)
addq $0x4, %r11
incq %r14
movslq 0x8c(%rsp), %rcx
cmpq %rcx, %r14
jl 0x4af134
incq %r9
cmpq 0x8(%rsp), %r9
jne 0x4af0dc
jmp 0x4af387
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x98(%rsp), %rdi
movq %rax, (%rdi)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x13c9f0
movq %rbx, 0x8(%rsp)
movq 0x23fdc8(%rip), %rbx # 0x6ef0c0
addq $0x10, %rbx
movq %r14, (%rsp)
movl %r15d, %eax
subl %r12d, %eax
cltd
idivl %r14d
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r13
movb $0x1, 0x8(%rax)
movq %rbx, (%rax)
movl $0x20, %edi
callq 0x1387d0
leaq -0x15b1(%rip), %rcx # 0x4add80
movq %rcx, (%rax)
movl %r12d, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x98(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r13)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x1393d0
addl %ebp, %r12d
decl %r14d
jne 0x4af300
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x143df0
movq %rbx, %rdi
callq 0x13f120
movq %fs:0x28, %rax
cmpq 0xa0(%rsp), %rax
jne 0x4af3ac
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qimagescale_sse4.cpp |
comp_func_Source_rgbafp_avx2(QRgbaFloat<float>*, QRgbaFloat<float> const*, int, unsigned int) | void QT_FASTCALL comp_func_Source_rgbafp_avx2(QRgbaFloat32 *dst, const QRgbaFloat32 *src, int length, uint const_alpha)
{
Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]
if (const_alpha == 255) {
::memcpy(dst, src, length * sizeof(QRgbaFloat32));
} else {
const float ca = const_alpha / 255.f;
const float cia = 1.0f - ca;
const __m128 constAlphaVector = _mm_set1_ps(ca);
const __m128 oneMinusConstAlpha = _mm_set1_ps(cia);
const __m256 constAlphaVector256 = _mm256_set1_ps(ca);
const __m256 oneMinusConstAlpha256 = _mm256_set1_ps(cia);
int x = 0;
for (; x < length - 1; x += 2) {
__m256 srcVector = _mm256_loadu_ps((const float *)&src[x]);
__m256 dstVector = _mm256_loadu_ps((const float *)&dst[x]);
srcVector = _mm256_mul_ps(srcVector, constAlphaVector256);
dstVector = _mm256_mul_ps(dstVector, oneMinusConstAlpha256);
dstVector = _mm256_add_ps(dstVector, srcVector);
_mm256_storeu_ps((float *)&dst[x], dstVector);
}
if (x < length) {
__m128 srcVector = _mm_loadu_ps((const float *)&src[x]);
__m128 dstVector = _mm_loadu_ps((const float *)&dst[x]);
srcVector = _mm_mul_ps(srcVector, constAlphaVector);
dstVector = _mm_mul_ps(dstVector, oneMinusConstAlpha);
dstVector = _mm_add_ps(dstVector, srcVector);
_mm_storeu_ps((float *)&dst[x], dstVector);
}
}
} | endbr64
cmpl $0xff, %ecx
jne 0x4b1015
movslq %edx, %rdx
shlq $0x4, %rdx
jmp 0x137aa0
movl %ecx, %eax
vcvtsi2ss %rax, %xmm0, %xmm0
vdivss 0xc4f04(%rip), %xmm0, %xmm0 # 0x575f28
vmovss 0xc4ef4(%rip), %xmm1 # 0x575f20
vsubss %xmm0, %xmm1, %xmm1
vbroadcastss %xmm0, %ymm0
vbroadcastss %xmm1, %ymm1
xorl %eax, %eax
cmpl $0x2, %edx
jl 0x4b106c
leal -0x1(%rdx), %ecx
xorl %r8d, %r8d
xorl %eax, %eax
vmulps (%rsi,%r8), %ymm0, %ymm2
vmulps (%rdi,%r8), %ymm1, %ymm3
vaddps %ymm3, %ymm2, %ymm2
vmovups %ymm2, (%rdi,%r8)
addq $0x2, %rax
addq $0x20, %r8
cmpq %rcx, %rax
jb 0x4b1049
cmpl %edx, %eax
jge 0x4b1089
movl %eax, %eax
shlq $0x4, %rax
vmulps (%rsi,%rax), %xmm0, %xmm0
vmulps (%rdi,%rax), %xmm1, %xmm1
vaddps %xmm1, %xmm0, %xmm0
vmovups %xmm0, (%rdi,%rax)
vzeroupper
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper_avx2.cpp |
comp_func_solid_Source_rgbafp_avx2(QRgbaFloat<float>*, int, QRgbaFloat<float>, unsigned int) | void QT_FASTCALL comp_func_solid_Source_rgbafp_avx2(QRgbaFloat32 *dst, int length, QRgbaFloat32 color, uint const_alpha)
{
Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]
if (const_alpha == 255) {
for (int i = 0; i < length; ++i)
dst[i] = color;
} else {
const float a = const_alpha / 255.0f;
const __m128 alphaVector = _mm_set1_ps(a);
const __m128 minusAlphaVector = _mm_set1_ps(1.0f - a);
__m128 colorVector = _mm_loadu_ps((const float *)&color);
colorVector = _mm_mul_ps(colorVector, alphaVector);
const __m256 colorVector256 = _mm256_insertf128_ps(_mm256_castps128_ps256(colorVector), colorVector, 1);
const __m256 minusAlphaVector256 = _mm256_set1_ps(1.0f - a);
int x = 0;
for (; x < length - 1; x += 2) {
__m256 dstVector = _mm256_loadu_ps((const float *)&dst[x]);
dstVector = _mm256_mul_ps(dstVector, minusAlphaVector256);
dstVector = _mm256_add_ps(dstVector, colorVector256);
_mm256_storeu_ps((float *)&dst[x], dstVector);
}
if (x < length) {
__m128 dstVector = _mm_loadu_ps((const float *)&dst[x]);
dstVector = _mm_mul_ps(dstVector, minusAlphaVector);
dstVector = _mm_add_ps(dstVector, colorVector);
_mm_storeu_ps((float *)&dst[x], dstVector);
}
}
} | endbr64
vmovlhps %xmm1, %xmm0, %xmm1 # xmm1 = xmm0[0],xmm1[0]
cmpl $0xff, %edx
jne 0x4b1643
testl %esi, %esi
jle 0x4b163f
movl %esi, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
vmovaps %xmm1, (%rdi,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x4b1631
vzeroupper
retq
movl %edx, %eax
vcvtsi2ss %rax, %xmm2, %xmm0
vdivss 0xc48d6(%rip), %xmm0, %xmm0 # 0x575f28
vbroadcastss %xmm0, %xmm2
vmovss 0xc48c1(%rip), %xmm3 # 0x575f20
vsubss %xmm0, %xmm3, %xmm0
vbroadcastss %xmm0, %ymm0
vmulps %xmm2, %xmm1, %xmm1
xorl %eax, %eax
cmpl $0x2, %esi
jl 0x4b169a
vinsertf128 $0x1, %xmm1, %ymm1, %ymm2
leal -0x1(%rsi), %ecx
xorl %eax, %eax
movq %rdi, %rdx
vmulps (%rdx), %ymm0, %ymm3
vaddps %ymm3, %ymm2, %ymm3
vmovups %ymm3, (%rdx)
addq $0x2, %rax
addq $0x20, %rdx
cmpq %rcx, %rax
jb 0x4b1681
cmpl %esi, %eax
jge 0x4b163f
movl %eax, %eax
shlq $0x4, %rax
vmulps (%rdi,%rax), %xmm0, %xmm0
vaddps %xmm0, %xmm1, %xmm0
vmovups %xmm0, (%rdi,%rax)
vzeroupper
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper_avx2.cpp |
storeRGBX16FFromRGBA32F_avx2(unsigned char*, QRgbaFloat<float> const*, int, int, QList<unsigned int> const*, QDitherInfo*) | void QT_FASTCALL storeRGBX16FFromRGBA32F_avx2(uchar *dest, const QRgbaFloat32 *src, int index, int count,
const QList<QRgb> *, QDitherInfo *)
{
quint64 *d = reinterpret_cast<quint64 *>(dest) + index;
const __m128 *s = reinterpret_cast<const __m128 *>(src);
const __m128 zero = _mm_set_ps(1.0f, 0.0f, 0.0f, 0.0f);
for (int i = 0; i < count; ++i) {
__m128 vsf = _mm_loadu_ps(reinterpret_cast<const float *>(s + i));
const __m128 vsa = _mm_permute_ps(vsf, _MM_SHUFFLE(3, 3, 3, 3));
const float a = _mm_cvtss_f32(vsa);
if (a == 1.0f)
{ }
else if (a == 0.0f)
vsf = zero;
else {
__m128 vsr = _mm_rcp_ps(vsa);
vsr = _mm_sub_ps(_mm_add_ps(vsr, vsr), _mm_mul_ps(vsr, _mm_mul_ps(vsr, vsa)));
vsf = _mm_mul_ps(vsf, vsr);
vsf = _mm_insert_ps(vsf, _mm_set_ss(1.0f), 0x30);
}
_mm_storel_epi64((__m128i *)(d + i), _mm_cvtps_ph(vsf, 0));
}
} | endbr64
testl %ecx, %ecx
jle 0x4b330b
movslq %edx, %rax
leaq (%rdi,%rax,8), %rax
movl %ecx, %ecx
shlq $0x3, %rcx
xorl %edx, %edx
vmovss 0xc2c79(%rip), %xmm0 # 0x575f20
vmovaps 0xdc821(%rip), %xmm1 # 0x58fad0
vxorps %xmm2, %xmm2, %xmm2
vmovups (%rsi,%rdx,2), %xmm3
vbroadcastss 0xc(%rsi,%rdx,2), %xmm4
vucomiss %xmm0, %xmm4
jne 0x4b32cd
jp 0x4b32cd
vmovaps %xmm3, %xmm5
jmp 0x4b32fb
vucomiss %xmm2, %xmm4
vmovaps %xmm1, %xmm5
jne 0x4b32d9
jnp 0x4b32fb
vrcpps %xmm4, %xmm5
vaddps %xmm5, %xmm5, %xmm6
vmulps %xmm5, %xmm4, %xmm4
vmulps %xmm4, %xmm5, %xmm4
vsubps %xmm4, %xmm6, %xmm4
vmulps %xmm4, %xmm3, %xmm3
vinsertps $0x30, 0xc2c25(%rip), %xmm3, %xmm5 # xmm5 = xmm3[0,1,2],mem[0]
vcvtps2ph $0x0, %xmm5, (%rax,%rdx)
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0x4b32b3
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper_avx2.cpp |
hb_qt_font_get_glyph_h_advance(hb_font_t*, void*, unsigned int, void*) | static hb_position_t
_hb_qt_font_get_glyph_h_advance(hb_font_t *font, void *font_data,
hb_codepoint_t glyph,
void * /*user_data*/)
{
QFontEngine *fe = static_cast<QFontEngine *>(font_data);
Q_ASSERT(fe);
QFixed advance;
QGlyphLayout g;
g.numGlyphs = 1;
g.glyphs = &glyph;
g.advances = &advance;
fe->recalcAdvances(&g, QFontEngine::ShaperFlags(hb_qt_font_get_use_design_metrics(font)));
return advance.value();
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
leaq 0xc(%rsp), %rax
movl %edx, (%rax)
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
movaps 0xc0f21(%rip), %xmm0 # 0x574680
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x20(%r14)
movaps %xmm0, (%r14)
movaps %xmm0, 0x10(%r14)
movl $0x1, 0x28(%r14)
movq %rax, 0x8(%r14)
movq %r15, 0x10(%r14)
leaq 0x25991f(%rip), %rsi # 0x70d0a8
callq 0x144180
movq (%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq *0x68(%rcx)
movl (%r15), %eax
movq %fs:0x28, %rcx
cmpq 0x48(%rsp), %rcx
jne 0x4b37b9
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/text/qharfbuzzng.cpp |
hb_unicode_funcs_t::_hb_unicode_funcs_t() | _hb_unicode_funcs_t()
{
funcs = hb_unicode_funcs_create(NULL);
hb_unicode_funcs_set_combining_class_func(funcs, _hb_qt_unicode_combining_class, NULL, NULL);
hb_unicode_funcs_set_general_category_func(funcs, _hb_qt_unicode_general_category, NULL, NULL);
hb_unicode_funcs_set_mirroring_func(funcs, _hb_qt_unicode_mirroring, NULL, NULL);
hb_unicode_funcs_set_script_func(funcs, _hb_qt_unicode_script, NULL, NULL);
hb_unicode_funcs_set_compose_func(funcs, _hb_qt_unicode_compose, NULL, NULL);
hb_unicode_funcs_set_decompose_func(funcs, _hb_qt_unicode_decompose, NULL, NULL);
} | endbr64
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x138b30
movq %rax, (%rbx)
leaq -0x4e1(%rip), %rsi # 0x4b396e
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x13ffe0
movq (%rbx), %rdi
leaq -0x4e6(%rip), %rsi # 0x4b397f
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1383d0
movq (%rbx), %rdi
leaq -0x4df(%rip), %rsi # 0x4b3999
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x137660
movq (%rbx), %rdi
leaq -0x4e4(%rip), %rsi # 0x4b39a7
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1476d0
movq (%rbx), %rdi
leaq -0x3528ba(%rip), %rsi # 0x1615e4
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1445a0
movq (%rbx), %rdi
leaq -0x4f0(%rip), %rsi # 0x4b39c1
xorl %edx, %edx
xorl %ecx, %ecx
popq %rbx
jmp 0x13d4a0
nop
| /qt[P]qtbase/src/gui/text/qharfbuzzng.cpp |
QTextOdfWriter::writeInlineCharacter(QXmlStreamWriter&, QTextFragment const&) const | void QTextOdfWriter::writeInlineCharacter(QXmlStreamWriter &writer, const QTextFragment &fragment) const
{
writer.writeStartElement(drawNS, QString::fromLatin1("frame"));
if (m_strategy == nullptr) {
// don't do anything.
}
else if (fragment.charFormat().isImageFormat()) {
QTextImageFormat imageFormat = fragment.charFormat().toImageFormat();
writer.writeAttribute(drawNS, QString::fromLatin1("name"), imageFormat.name());
QByteArray data;
QString mimeType;
qreal width = 0;
qreal height = 0;
QImage image;
QString name = imageFormat.name();
if (name.startsWith(":/"_L1)) // auto-detect resources
name.prepend("qrc"_L1);
QUrl url = QUrl(name);
const QVariant variant = m_document->resource(QTextDocument::ImageResource, url);
if (variant.userType() == QMetaType::QPixmap || variant.userType() == QMetaType::QImage) {
image = qvariant_cast<QImage>(variant);
} else if (variant.userType() == QMetaType::QByteArray) {
data = variant.toByteArray();
QBuffer buffer(&data);
buffer.open(QIODevice::ReadOnly);
probeImageData(&buffer, &image, &mimeType, &width, &height);
} else {
// try direct loading
QFile file(imageFormat.name());
if (file.open(QIODevice::ReadOnly) && !probeImageData(&file, &image, &mimeType, &width, &height)) {
file.seek(0);
data = file.readAll();
}
}
if (! image.isNull()) {
QBuffer imageBytes;
int imgQuality = imageFormat.quality();
if (imgQuality >= 100 || imgQuality <= 0 || image.hasAlphaChannel()) {
QImageWriter imageWriter(&imageBytes, "png");
imageWriter.write(image);
data = imageBytes.data();
mimeType = QStringLiteral("image/png");
} else {
// Write images without alpha channel as jpg with quality set by QTextImageFormat
QImageWriter imageWriter(&imageBytes, "jpg");
imageWriter.setQuality(imgQuality);
imageWriter.write(image);
data = imageBytes.data();
mimeType = QStringLiteral("image/jpg");
}
width = image.width();
height = image.height();
}
if (!data.isEmpty()) {
if (imageFormat.hasProperty(QTextFormat::ImageWidth)) {
width = imageFormat.width();
}
if (imageFormat.hasProperty(QTextFormat::ImageHeight)) {
height = imageFormat.height();
}
QString filename = m_strategy->createUniqueImageName();
m_strategy->addFile(filename, mimeType, data);
writer.writeAttribute(svgNS, QString::fromLatin1("width"), pixelToPoint(width));
writer.writeAttribute(svgNS, QString::fromLatin1("height"), pixelToPoint(height));
writer.writeAttribute(textNS, QStringLiteral("anchor-type"), QStringLiteral("as-char"));
writer.writeStartElement(drawNS, QString::fromLatin1("image"));
writer.writeAttribute(xlinkNS, QString::fromLatin1("href"), filename);
writer.writeEndElement(); // image
}
}
writer.writeEndElement(); // frame
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x190(%rsp)
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
movq 0x80(%rdi), %r12
movq %rdi, 0x18(%rsp)
movq 0x88(%rdi), %r13
orq %r14, %r13
leaq 0xf6623(%rip), %rdx # 0x5ac838
leaq 0x170(%rsp), %rbp
movl $0x5, %esi
movq %rbp, %rdi
callq 0x143140
movq 0x8(%rbp), %rcx
movq 0x10(%rbp), %r8
orq %r14, %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x138c80
movq (%rbp), %rax
testq %rax, %rax
je 0x4b6268
lock
decl (%rax)
jne 0x4b6268
movq 0x170(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x18(%rsp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x4b6f6f
leaq 0x170(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1451b0
movq %r12, %rdi
callq 0x146140
cmpl $0x2, %eax
jne 0x4b657e
leaq 0x170(%rsp), %r12
movq %r12, %rdi
movl $0x2f00, %esi # imm = 0x2F00
callq 0x138f70
movl %eax, %ebp
movq %r12, %rdi
callq 0x13c1a0
cmpl $0x1, %ebp
jne 0x4b6f6f
movaps 0xbe3b2(%rip), %xmm0 # 0x574680
leaq 0x160(%rsp), %r12
movaps %xmm0, (%r12)
leaq 0x170(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x1451b0
movq %r12, %rdi
movq %r13, %rsi
callq 0x13acd0
movq %r13, %rdi
callq 0x13c1a0
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x88(%rax), %r13
orq %r14, %r13
leaq 0x108b53(%rip), %rdx # 0x5bee76
leaq 0x170(%rsp), %rbp
movl $0x4, %esi
movq %rbp, %rdi
callq 0x143140
movq 0x8(%rbp), %r15
movq 0x10(%rbp), %rbp
orq %r14, %rbp
leaq 0x140(%rsp), %r12
movq %r12, %rdi
leaq 0x160(%rsp), %rsi
movl $0x5000, %edx # imm = 0x5000
callq 0x1440d0
movq 0x8(%r12), %rax
movq %rax, 0x130(%rsp)
movq 0x10(%r12), %rax
orq %r14, %rax
movq %rax, 0x138(%rsp)
movups 0x130(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq 0x148540
movq (%r12), %rax
testq %rax, %rax
je 0x4b63c9
lock
decl (%rax)
jne 0x4b63c9
movq 0x140(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x170(%rsp), %rax
testq %rax, %rax
je 0x4b63f2
lock
decl (%rax)
jne 0x4b63f2
movq 0x170(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
xorl %eax, %eax
movq %rax, 0x120(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x110(%rsp)
movq %rax, 0x100(%rsp)
movaps %xmm0, 0xf0(%rsp)
movq %rax, 0xe8(%rsp)
movq %rax, 0xe0(%rsp)
movabsq $-0x5555555555555556, %r13 # imm = 0xAAAAAAAAAAAAAAAA
leaq 0xc0(%rsp), %rdi
movq %r13, 0x10(%rdi)
movaps 0xbe23c(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rdi)
callq 0x138250
leaq 0xa0(%rsp), %rbx
movq %r13, 0x10(%rbx)
movaps 0xbe221(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rbx)
leaq 0x160(%rsp), %rsi
movq %rbx, %rdi
movl $0x5000, %edx # imm = 0x5000
callq 0x1440d0
leaq 0xf9410(%rip), %rdx # 0x5af88e
movl $0x2, %esi
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x13dbb0
testb %al, %al
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
je 0x4b64b9
leaq 0xf93ec(%rip), %rcx # 0x5af891
leaq 0xa0(%rsp), %rdi
movl $0x3, %edx
xorl %esi, %esi
callq 0x137400
leaq 0x98(%rsp), %rbx
movq %r13, (%rbx)
leaq 0xa0(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x145b50
leaq 0x170(%rsp), %r15
movaps 0xbe19b(%rip), %xmm0 # 0x574680
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq 0x18(%rsp), %rax
movq 0xc8(%rax), %rsi
movq %r15, %rdi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x13d850
movq %r15, %rdi
callq 0x3ce810
cmpl $0x1001, %eax # imm = 0x1001
je 0x4b6531
leaq 0x170(%rsp), %rdi
callq 0x3ce810
cmpl $0x1006, %eax # imm = 0x1006
jne 0x4b65e7
leaq 0x21bbd0(%rip), %rax # 0x6d2108
leaq 0x140(%rsp), %rsi
movq %rax, (%rsi)
movq 0x188(%rsp), %rax
andq $-0x4, %rax
leaq 0x80(%rsp), %rdi
movq %rax, (%rdi)
callq 0x16a00a
testb %al, %al
je 0x4b658b
testb $0x1, 0x188(%rsp)
jne 0x4b66cc
leaq 0x170(%rsp), %rsi
jmp 0x4b66db
leaq 0x170(%rsp), %rdi
jmp 0x4b6f6a
leaq 0x80(%rsp), %rdi
movq %r13, 0x10(%rdi)
movaps 0xbe0e2(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rdi)
callq 0x138250
movq %r15, %rdi
callq 0x139130
testb $0x1, 0x188(%rsp)
je 0x4b65c7
movq 0x170(%rsp), %rcx
movslq 0x4(%rcx), %r15
addq %rcx, %r15
movq 0x140(%rsp), %rdx
leaq 0x80(%rsp), %rcx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1376b0
jmp 0x4b66e8
leaq 0x170(%rsp), %rdi
callq 0x3ce810
cmpl $0xc, %eax
jne 0x4b6860
leaq 0x140(%rsp), %rbx
leaq 0x170(%rsp), %rsi
movq %rbx, %rdi
callq 0x1403a0
movq 0x110(%rsp), %rax
movups 0x118(%rsp), %xmm0
movaps (%rbx), %xmm1
movq %rax, (%rbx)
movaps %xmm1, 0x110(%rsp)
movq 0x10(%rbx), %rcx
movups %xmm0, 0x8(%rbx)
movq %rcx, 0x120(%rsp)
testq %rax, %rax
je 0x4b6664
lock
decl (%rax)
jne 0x4b6664
movq 0x140(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x140(%rsp), %rbx
movapd 0xbe00c(%rip), %xmm0 # 0x574680
movapd %xmm0, (%rbx)
leaq 0x110(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x148220
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13bbb0
leaq 0xc0(%rsp), %rsi
leaq 0xf0(%rsp), %rdx
leaq 0xe8(%rsp), %rcx
leaq 0xe0(%rsp), %r8
movq %rbx, %rdi
callq 0x4b6fa1
movq %rbx, %rdi
callq 0x13a8a0
jmp 0x4b674e
movq 0x170(%rsp), %rax
movslq 0x4(%rax), %rsi
addq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x13f500
leaq 0x140(%rsp), %rbx
movq %r13, 0x10(%rbx)
movapd 0xbdf84(%rip), %xmm0 # 0x574680
movapd %xmm0, (%rbx)
movq %rbx, %rdi
callq 0x13ac20
movq 0x2390d1(%rip), %rax # 0x6ef7e0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x80(%rsp), %r15
movq 0x10(%r15), %rax
movq $0x0, 0x10(%r15)
movq 0xd0(%rsp), %rcx
movq %rax, 0xd0(%rsp)
movq %rcx, 0x10(%rbx)
movq %rbx, %rdi
callq 0x13d330
movq %r15, %rdi
callq 0x13d330
movq 0x10(%rsp), %rbx
leaq 0xc0(%rsp), %rdi
callq 0x1469a0
testb %al, %al
jne 0x4b6ad6
leaq 0x80(%rsp), %rdi
movaps 0xbdf09(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x136f20
leaq 0x160(%rsp), %rdi
movl $0x5014, %esi # imm = 0x5014
callq 0x138f70
movl %eax, %r15d
leal -0x64(%r15), %eax
cmpl $-0x63, %eax
jb 0x4b67b4
leaq 0xc0(%rsp), %rdi
callq 0x142890
testb %al, %al
je 0x4b699f
leaq 0x58(%rsp), %rbx
movq %r13, (%rbx)
leaq 0xf90c4(%rip), %rsi # 0x5af887
leaq 0x140(%rsp), %r15
movq %r15, %rdi
movq $-0x1, %rdx
callq 0x144940
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x144ee0
movq (%r15), %rax
testq %rax, %rax
je 0x4b6811
lock
decl (%rax)
jne 0x4b6811
movq 0x140(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x58(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x13e2e0
leaq 0x80(%rsp), %rdi
callq 0x144290
leaq 0x110(%rsp), %rdi
movq %rax, %rsi
callq 0x13cef0
movq 0xf0(%rsp), %rdi
movq $0x0, 0xf0(%rsp)
leaq 0x108d41(%rip), %rax # 0x5bf59c
jmp 0x4b6a55
leaq 0x80(%rsp), %rbx
movapd 0xbde10(%rip), %xmm0 # 0x574680
movapd %xmm0, (%rbx)
leaq 0x140(%rsp), %r15
leaq 0x160(%rsp), %rsi
movq %r15, %rdi
movl $0x5000, %edx # imm = 0x5000
callq 0x1440d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x146cd0
movq (%r15), %rax
testq %rax, %rax
je 0x4b68c0
lock
decl (%rax)
jne 0x4b68c0
movq 0x140(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x80(%rsp), %rdi
movl $0x1, %esi
callq 0x142bd0
testb %al, %al
movq 0x10(%rsp), %rbx
je 0x4b698d
leaq 0x80(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0xf0(%rsp), %rdx
leaq 0xe8(%rsp), %rcx
leaq 0xe0(%rsp), %r8
callq 0x4b6fa1
testb %al, %al
jne 0x4b698d
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x144d10
leaq 0x140(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13dc90
movq 0x110(%rsp), %rax
movupd 0x118(%rsp), %xmm0
movaps (%r15), %xmm1
movq %rax, (%r15)
movaps %xmm1, 0x110(%rsp)
movq 0x10(%r15), %rcx
movupd %xmm0, 0x8(%r15)
movq %rcx, 0x120(%rsp)
testq %rax, %rax
je 0x4b6988
lock
decl (%rax)
jne 0x4b6988
movq 0x140(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x10(%rsp), %rbx
leaq 0x80(%rsp), %rdi
callq 0x1471c0
jmp 0x4b6753
leaq 0x58(%rsp), %rbx
movq %r13, (%rbx)
leaq 0x10857e(%rip), %rsi # 0x5bef2c
leaq 0x140(%rsp), %r12
movq %r12, %rdi
movq $-0x1, %rdx
callq 0x144940
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x144ee0
movq (%r12), %rax
testq %rax, %rax
je 0x4b69fd
lock
decl (%rax)
jne 0x4b69fd
movq 0x140(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13ef40
leaq 0xc0(%rsp), %rsi
movq %rbx, %rdi
callq 0x13e2e0
leaq 0x80(%rsp), %rdi
callq 0x144290
leaq 0x110(%rsp), %rdi
movq %rax, %rsi
callq 0x13cef0
movq 0xf0(%rsp), %rdi
movq $0x0, 0xf0(%rsp)
leaq 0x108b5b(%rip), %rax # 0x5bf5b0
movq %rax, 0xf8(%rsp)
movq $0x9, 0x100(%rsp)
testq %rdi, %rdi
je 0x4b6a82
lock
decl (%rdi)
jne 0x4b6a82
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x58(%rsp), %rdi
callq 0x143740
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
callq 0x141250
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0xe8(%rsp)
movq %rbx, %rdi
callq 0x147520
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0xe0(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x13a8a0
movq 0x10(%rsp), %rbx
cmpq $0x0, 0x120(%rsp)
je 0x4b6ec0
leaq 0x160(%rsp), %rdi
movl $0x5010, %esi # imm = 0x5010
callq 0x1415c0
testb %al, %al
je 0x4b6b16
leaq 0x160(%rsp), %rdi
movl $0x5010, %esi # imm = 0x5010
callq 0x146b30
movsd %xmm0, 0xe8(%rsp)
leaq 0x160(%rsp), %rdi
movl $0x5011, %esi # imm = 0x5011
callq 0x1415c0
testb %al, %al
je 0x4b6b47
leaq 0x160(%rsp), %rdi
movl $0x5011, %esi # imm = 0x5011
callq 0x146b30
movsd %xmm0, 0xe0(%rsp)
leaq 0x140(%rsp), %rbx
movq %r13, 0x10(%rbx)
movaps 0xbdb26(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rbx)
movq 0x18(%rsp), %r12
movq 0xd8(%r12), %rsi
movq %rbx, %rdi
callq 0x4beb72
movq 0xd8(%r12), %rdi
movq (%rdi), %rax
leaq 0xf0(%rsp), %rdx
leaq 0x110(%rsp), %rcx
movq %rbx, %rsi
callq *0x10(%rax)
movq 0xb0(%r12), %r15
movq 0xb8(%r12), %r12
orq %r14, %r12
leaq 0xf5df9(%rip), %rdx # 0x5ac9a6
leaq 0x80(%rsp), %rbx
movl $0x5, %esi
movq %rbx, %rdi
callq 0x143140
movq 0x8(%rbx), %r13
movq 0x10(%rbx), %rbx
orq %r14, %rbx
movsd 0xe8(%rsp), %xmm0
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
callq 0x4b7231
movq 0x8(%rbp), %rax
movq %rax, 0x70(%rsp)
movq 0x10(%rbp), %rax
orq %r14, %rax
movq %rax, 0x78(%rsp)
movups 0x70(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x148540
movq (%rbp), %rax
testq %rax, %rax
je 0x4b6c39
lock
decl (%rax)
jne 0x4b6c39
movq 0x58(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x4b6c62
lock
decl (%rax)
jne 0x4b6c62
movq 0x80(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x18(%rsp), %rax
movq 0xb0(%rax), %r15
movq 0xb8(%rax), %r12
orq %r14, %r12
leaq 0x1082e6(%rip), %rdx # 0x5bef65
leaq 0x80(%rsp), %rbx
movl $0x6, %esi
movq %rbx, %rdi
callq 0x143140
movq 0x8(%rbx), %r13
movq 0x10(%rbx), %rbx
orq %r14, %rbx
movsd 0xe0(%rsp), %xmm0
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
callq 0x4b7231
movq 0x8(%rbp), %rax
movq %rax, 0x48(%rsp)
movq 0x10(%rbp), %rax
orq %r14, %rax
movq %rax, 0x50(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x148540
movq (%rbp), %rax
testq %rax, %rax
je 0x4b6d0b
lock
decl (%rax)
jne 0x4b6d0b
movq 0x58(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x4b6d34
lock
decl (%rax)
jne 0x4b6d34
movq 0x80(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x18(%rsp), %r15
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
orq %r14, %rdx
leaq 0x108891(%rip), %rax # 0x5bf5dc
movq %rax, 0x38(%rsp)
leaq 0x7(%r14), %rax
movq %rax, 0x40(%rsp)
leaq 0xb(%r14), %r8
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x108857(%rip), %rcx # 0x5bf5c4
movq %r14, %r13
movq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x148540
movq 0x80(%r15), %rbx
movq 0x88(%r15), %r15
orq %r13, %r15
leaq 0xf3ed4(%rip), %rdx # 0x5aac69
leaq 0x80(%rsp), %r12
movl $0x5, %esi
movq %r12, %rdi
callq 0x143140
movq 0x8(%r12), %rcx
movq 0x10(%r12), %r8
orq %r13, %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x138c80
movq (%r12), %rax
testq %rax, %rax
je 0x4b6dea
lock
decl (%rax)
jne 0x4b6dea
movq 0x80(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rbx
movq 0xa0(%rax), %r14
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
orq %r12, %r14
leaq 0xf88bb(%rip), %rdx # 0x5af6cc
leaq 0x80(%rsp), %r15
movl $0x4, %esi
movq %r15, %rdi
callq 0x143140
movq 0x8(%r15), %rcx
movq 0x10(%r15), %r8
orq %r12, %r8
movq 0x148(%rsp), %rax
movq %rax, 0x28(%rsp)
orq 0x150(%rsp), %r12
movq %r12, 0x30(%rsp)
movupd 0x28(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x148540
movq (%r15), %rax
testq %rax, %rax
je 0x4b6e8a
lock
decl (%rax)
jne 0x4b6e8a
movq 0x80(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x143060
movq 0x140(%rsp), %rax
testq %rax, %rax
je 0x4b6ec0
lock
decl (%rax)
jne 0x4b6ec0
movq 0x140(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x170(%rsp), %rdi
callq 0x13e600
leaq 0x98(%rsp), %rdi
callq 0x138880
movq 0xa0(%rsp), %rax
testq %rax, %rax
je 0x4b6f03
lock
decl (%rax)
jne 0x4b6f03
movq 0xa0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0xc0(%rsp), %rdi
callq 0x13d330
movq 0xf0(%rsp), %rax
testq %rax, %rax
je 0x4b6f39
lock
decl (%rax)
jne 0x4b6f39
movq 0xf0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x110(%rsp), %rax
testq %rax, %rax
je 0x4b6f62
lock
decl (%rax)
jne 0x4b6f62
movq 0x110(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x160(%rsp), %rdi
callq 0x13c1a0
movq %rbx, %rdi
callq 0x143060
movq %fs:0x28, %rax
cmpq 0x190(%rsp), %rax
jne 0x4b6f9c
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/text/qtextodfwriter.cpp |
QTextOdfWriter::writeFormats(QXmlStreamWriter&, QSet<int> const&) const | void QTextOdfWriter::writeFormats(QXmlStreamWriter &writer, const QSet<int> &formats) const
{
writer.writeStartElement(officeNS, QString::fromLatin1("automatic-styles"));
QList<QTextFormat> allStyles = m_document->allFormats();
for (int formatIndex : formats) {
QTextFormat textFormat = allStyles.at(formatIndex);
switch (textFormat.type()) {
case QTextFormat::CharFormat:
if (textFormat.isTableCellFormat())
writeTableCellFormat(writer, textFormat.toTableCellFormat(), formatIndex, allStyles);
else
writeCharacterFormat(writer, textFormat.toCharFormat(), formatIndex);
break;
case QTextFormat::BlockFormat:
writeBlockFormat(writer, textFormat.toBlockFormat(), formatIndex);
break;
case QTextFormat::ListFormat:
writeListFormat(writer, textFormat.toListFormat(), formatIndex);
break;
case QTextFormat::FrameFormat:
if (textFormat.isTableFormat())
writeTableFormat(writer, textFormat.toTableFormat(), formatIndex);
else
writeFrameFormat(writer, textFormat.toFrameFormat(), formatIndex);
break;
}
}
writer.writeEndElement(); // automatic-styles
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
movq 0x8(%rdi), %r12
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
movq %rdi, (%rsp)
movq 0x10(%rdi), %rbp
orq %r13, %rbp
leaq 0x107bd0(%rip), %rdx # 0x5bef30
leaq 0x10(%rsp), %r15
movl $0x10, %esi
movq %r15, %rdi
callq 0x143140
movq 0x8(%r15), %rcx
orq 0x10(%r15), %r13
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r13, %r8
callq 0x138c80
movq (%r15), %rax
testq %rax, %rax
je 0x4b73b1
lock
decl (%rax)
jne 0x4b73b1
movq 0x10(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x10(%rsp), %rdi
movq %rax, 0x10(%rdi)
movaps 0xbd2b5(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rdi)
movq (%rsp), %rax
movq 0xc8(%rax), %rsi
callq 0x141aa0
movq (%r14), %r12
testq %r12, %r12
je 0x4b73f5
movq 0x20(%r12), %rax
cmpb $-0x1, (%rax)
je 0x4b73fd
xorl %r13d, %r13d
jmp 0x4b7446
xorl %r12d, %r12d
xorl %r13d, %r13d
jmp 0x4b743a
movq 0x10(%r12), %rdx
movl $0x1, %ecx
xorl %r13d, %r13d
cmpq %rcx, %rdx
je 0x4b7437
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 0x4b740a
decq %rcx
movq %rcx, %r13
jmp 0x4b743a
xorl %r12d, %r12d
movq %r12, %rax
orq %r13, %rax
je 0x4b7656
leaq 0x90(%rsp), %r15
leaq 0x10793b(%rip), %rbx # 0x5bed90
movq 0x20(%r12), %rax
movq %r13, %rcx
shrq $0x7, %rcx
leaq (%rcx,%rcx,8), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdx
movl %r13d, %esi
andl $0x7f, %esi
movq 0x80(%rax,%rcx), %rax
movzbl (%rsi,%rdx), %ecx
movslq (%rax,%rcx,4), %rbp
movaps 0xbd1f6(%rip), %xmm0 # 0x574680
movaps %xmm0, 0x90(%rsp)
movq %rbp, %rsi
shlq $0x4, %rsi
addq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x145600
movq %r15, %rdi
callq 0x146140
decl %eax
cmpl $0x4, %eax
ja 0x4b7604
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1391d0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x4b94ae
movq %r14, %rdi
leaq 0x1078a0(%rip), %rbx # 0x5bed90
jmp 0x4b75ff
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x144ba0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x4baca8
jmp 0x4b75fc
movq %r15, %rdi
callq 0x146140
cmpl $0x2, %eax
jne 0x4b75b4
movq %r15, %rdi
movl $0x2f00, %esi # imm = 0x2F00
callq 0x138f70
cmpl $0x3, %eax
jne 0x4b75b4
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x13afa0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movl %ebp, %ecx
leaq 0x10(%rsp), %r8
callq 0x4b7694
jmp 0x4b75fc
movq %r15, %rdi
callq 0x146140
cmpl $0x5, %eax
jne 0x4b75d9
movq %r15, %rdi
movl $0x2f00, %esi # imm = 0x2F00
callq 0x138f70
cmpl $0x2, %eax
jne 0x4b75d9
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x146530
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x4bb7ae
jmp 0x4b75fc
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x143950
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x4b78c2
jmp 0x4b75fc
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x140f90
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x4bc6da
movq %r14, %rdi
callq 0x13c1a0
movq %r15, %rdi
callq 0x140170
movq 0x10(%r12), %rax
decq %rax
cmpq %r13, %rax
je 0x4b763e
incq %r13
movq %r13, %rcx
shrq $0x7, %rcx
leaq (%rcx,%rcx,8), %rcx
shlq $0x4, %rcx
addq 0x20(%r12), %rcx
movl %r13d, %edx
andl $0x7f, %edx
cmpb $-0x1, (%rdx,%rcx)
je 0x4b7614
jmp 0x4b7644
xorl %r12d, %r12d
xorl %r13d, %r13d
testq %r12, %r12
jne 0x4b7455
testq %r13, %r13
jne 0x4b7455
movq 0x8(%rsp), %rdi
callq 0x143060
leaq 0x10(%rsp), %rdi
callq 0x40b090
movq %fs:0x28, %rax
cmpq 0xa0(%rsp), %rax
jne 0x4b768f
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/text/qtextodfwriter.cpp |
QTextOdfWriter::tableCellStyleElement(QXmlStreamWriter&, int const&, QTextTableCellFormat const&, bool, int, QTextTableFormat) const | void QTextOdfWriter::tableCellStyleElement(QXmlStreamWriter &writer, const int &formatIndex,
const QTextTableCellFormat &format,
bool hasBorder, int tableId,
const QTextTableFormat tableFormatTmp) const {
writer.writeStartElement(styleNS, QString::fromLatin1("style"));
if (hasBorder) {
writer.writeAttribute(styleNS, QString::fromLatin1("name"),
QString::fromLatin1("TB%1.%2").arg(tableId).arg(formatIndex));
} else {
writer.writeAttribute(styleNS, QString::fromLatin1("name"), QString::fromLatin1("T%1").arg(formatIndex));
}
writer.writeAttribute(styleNS, QString::fromLatin1("family"), QString::fromLatin1("table-cell"));
writer.writeEmptyElement(styleNS, QString::fromLatin1("table-cell-properties"));
if (hasBorder) {
writer.writeAttribute(foNS, QString::fromLatin1("border"),
pixelToPoint(tableFormatTmp.border()) + " "_L1
+ borderStyleName(tableFormatTmp.borderStyle()) + " "_L1
+ tableFormatTmp.borderBrush().color().name(QColor::HexRgb));
}
qreal topPadding = format.topPadding();
qreal padding = topPadding + tableFormatTmp.cellPadding();
if (padding > 0 && topPadding == format.bottomPadding()
&& topPadding == format.leftPadding() && topPadding == format.rightPadding()) {
writer.writeAttribute(foNS, QString::fromLatin1("padding"), pixelToPoint(padding));
}
else {
if (padding > 0)
writer.writeAttribute(foNS, QString::fromLatin1("padding-top"), pixelToPoint(padding));
padding = format.bottomPadding() + tableFormatTmp.cellPadding();
if (padding > 0)
writer.writeAttribute(foNS, QString::fromLatin1("padding-bottom"),
pixelToPoint(padding));
padding = format.leftPadding() + tableFormatTmp.cellPadding();
if (padding > 0)
writer.writeAttribute(foNS, QString::fromLatin1("padding-left"),
pixelToPoint(padding));
padding = format.rightPadding() + tableFormatTmp.cellPadding();
if (padding > 0)
writer.writeAttribute(foNS, QString::fromLatin1("padding-right"),
pixelToPoint(padding));
}
if (format.hasProperty(QTextFormat::TextVerticalAlignment)) {
QString pos;
switch (format.verticalAlignment()) { // TODO - review: doesn't handle all cases
case QTextCharFormat::AlignMiddle:
pos = QString::fromLatin1("middle"); break;
case QTextCharFormat::AlignTop:
pos = QString::fromLatin1("top"); break;
case QTextCharFormat::AlignBottom:
pos = QString::fromLatin1("bottom"); break;
default:
pos = QString::fromLatin1("automatic"); break;
}
writer.writeAttribute(styleNS, QString::fromLatin1("vertical-align"), pos);
}
// TODO
// ODF just search for style-table-cell-properties-attlist)
// QTextFormat::BackgroundImageUrl
// format.background
writer.writeEndElement(); // style
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movl %r9d, 0x40(%rsp)
movl %r8d, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, 0x290(%rsp)
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
movq 0x38(%rdi), %rbx
movq %rdi, 0x30(%rsp)
movq 0x40(%rdi), %r15
orq %rbp, %r15
leaq 0x107e1b(%rip), %rdx # 0x5c4cc1
leaq 0x1d0(%rsp), %r12
movl $0x5, %esi
movq %r12, %rdi
callq 0x143140
movq 0x8(%r12), %rcx
movq 0x10(%r12), %r8
orq %rbp, %r8
movq %r14, 0x28(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x138c80
movq (%r12), %rax
testq %rax, %rax
je 0x4bcf00
lock
decl (%rax)
jne 0x4bcf00
movq 0x1d0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x40(%rax), %r12
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
orq %rbx, %r12
cmpb $0x0, 0x18(%rsp)
je 0x4bd094
leaq 0x101f45(%rip), %rdx # 0x5bee76
leaq 0x1d0(%rsp), %r15
movl $0x4, %esi
movq %r15, %rdi
callq 0x143140
movq 0x8(%r15), %rax
movq %rax, 0x58(%rsp)
movq 0x10(%r15), %r15
orq %rbx, %r15
leaq 0x101f9e(%rip), %rdx # 0x5beefb
leaq 0x268(%rsp), %r14
movl $0x7, %esi
movq %r14, %rdi
callq 0x143140
movslq 0x40(%rsp), %rdx
leaq 0x140(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movl $0xa, %r8d
movl $0x20, %r9d
callq 0x141ec0
movslq (%r13), %rdx
leaq 0x180(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
xorl %ecx, %ecx
movl $0xa, %r8d
movl $0x20, %r9d
callq 0x141ec0
movq 0x8(%r14), %rax
movq %rax, 0x280(%rsp)
movq 0x10(%r14), %rax
orq %rbx, %rax
movq %rax, 0x288(%rsp)
movups 0x280(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %r12, %rdx
movq 0x58(%rsp), %rcx
movq %r15, %r8
callq 0x148540
movq (%r14), %rax
testq %rax, %rax
je 0x4bd022
lock
decl (%rax)
jne 0x4bd022
movq 0x180(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x140(%rsp), %rax
testq %rax, %rax
je 0x4bd04b
lock
decl (%rax)
jne 0x4bd04b
movq 0x140(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x268(%rsp), %rax
testq %rax, %rax
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
je 0x4bd07e
lock
decl (%rax)
jne 0x4bd07e
movq 0x268(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x1d0(%rsp), %rax
testq %rax, %rax
jne 0x4bd1a0
jmp 0x4bd1bc
leaq 0x101ddb(%rip), %rdx # 0x5bee76
leaq 0x1d0(%rsp), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x143140
movq 0x8(%r14), %r15
movq 0x10(%r14), %rbp
orq %rbx, %rbp
leaq 0x101e41(%rip), %rdx # 0x5bef03
leaq 0x140(%rsp), %r14
movl $0x3, %esi
movq %r14, %rdi
callq 0x143140
movslq (%r13), %rdx
leaq 0x180(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movl $0xa, %r8d
movl $0x20, %r9d
callq 0x141ec0
movq 0x8(%r13), %rax
movq %rax, 0x258(%rsp)
movq 0x10(%r13), %rax
orq %rbx, %rax
movq %rax, 0x260(%rsp)
movups 0x258(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq 0x148540
movq (%r13), %rax
testq %rax, %rax
je 0x4bd160
lock
decl (%rax)
jne 0x4bd160
movq 0x180(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x140(%rsp), %rax
testq %rax, %rax
je 0x4bd189
lock
decl (%rax)
jne 0x4bd189
movq 0x140(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x1d0(%rsp), %rax
testq %rax, %rax
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
je 0x4bd1bc
lock
decl (%rax)
jne 0x4bd1bc
movq 0x1d0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rbx
movq 0x40(%rax), %r15
orq %r12, %r15
leaq 0xea4f6(%rip), %rdx # 0x5a76c9
leaq 0x1d0(%rsp), %r14
movl $0x6, %esi
movq %r14, %rdi
callq 0x143140
movq 0x8(%r14), %rbp
movq 0x10(%r14), %r14
orq %r12, %r14
leaq 0x101ccb(%rip), %rdx # 0x5beec5
leaq 0x180(%rsp), %r13
movl $0xa, %esi
movq %r13, %rdi
callq 0x143140
movq 0x8(%r13), %rax
movq %rax, 0x248(%rsp)
movq 0x10(%r13), %rax
orq %r12, %rax
movq %rax, 0x250(%rsp)
movupd 0x248(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movq %r14, %r8
callq 0x148540
movq (%r13), %rax
testq %rax, %rax
je 0x4bd273
lock
decl (%rax)
jne 0x4bd273
movq 0x180(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x1d0(%rsp), %rax
testq %rax, %rax
je 0x4bd29c
lock
decl (%rax)
jne 0x4bd29c
movq 0x1d0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rbx
movq 0x40(%rax), %r14
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
orq %r12, %r14
leaq 0x101fcd(%rip), %rdx # 0x5bf28a
leaq 0x1d0(%rsp), %r15
movl $0x15, %esi
movq %r15, %rdi
callq 0x143140
movq 0x8(%r15), %rcx
movq 0x10(%r15), %r8
orq %r12, %r8
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x139a80
movq (%r15), %rax
testq %rax, %rax
je 0x4bd311
lock
decl (%rax)
jne 0x4bd311
movq 0x1d0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x2d0(%rsp), %r15
cmpb $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rbx
je 0x4bd725
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x58(%rax), %rbp
orq %r12, %rbp
leaq 0xeed20(%rip), %rdx # 0x5ac065
leaq 0x268(%rsp), %rbx
movl $0x6, %esi
movq %rbx, %rdi
callq 0x143140
movq 0x8(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rbx), %r13
orq %r12, %r13
movq %r15, %rdi
movl $0x4000, %esi # imm = 0x4000
callq 0x146b30
leaq 0x120(%rsp), %rbx
movq %rbx, %rdi
callq 0x4b7231
movaps (%rbx), %xmm0
movaps %xmm0, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
movq 0x10(%rbx), %r14
movq $0x0, 0x10(%rbx)
movq %r15, %rdi
movl $0x4010, %esi # imm = 0x4010
callq 0x138f70
cmpl $0xa, %eax
ja 0x4bd442
movl %eax, %eax
leaq 0x101a74(%rip), %rcx # 0x5bee34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xeeebc(%rip), %rdx # 0x5ac28d
jmp 0x4bd41d
leaq 0xeeeba(%rip), %rdx # 0x5ac294
jmp 0x4bd41d
leaq 0xc1525(%rip), %rdx # 0x57e908
leaq 0x100(%rsp), %rdi
movl $0x4, %esi
jmp 0x4bd453
leaq 0xeeec3(%rip), %rdx # 0x5ac2bc
jmp 0x4bd433
leaq 0xeeeb3(%rip), %rdx # 0x5ac2b5
jmp 0x4bd41d
leaq 0xeee90(%rip), %rdx # 0x5ac29b
jmp 0x4bd433
leaq 0xeee8d(%rip), %rdx # 0x5ac2a1
jmp 0x4bd41d
leaq 0xeeea5(%rip), %rdx # 0x5ac2c2
leaq 0x100(%rsp), %rdi
movl $0x6, %esi
jmp 0x4bd453
leaq 0xfc780(%rip), %rdx # 0x5b9bb3
leaq 0x100(%rsp), %rdi
movl $0x5, %esi
jmp 0x4bd453
leaq 0xbad28(%rip), %rdx # 0x578171
leaq 0x100(%rsp), %rdi
xorl %esi, %esi
callq 0x143140
movl $0x1, %eax
movq %rax, 0x158(%rsp)
leaq 0xbcac6(%rip), %rcx # 0x579f32
movq %rcx, 0x160(%rsp)
movq 0x110(%rsp), %rdx
xorl %r15d, %r15d
movq %r15, 0x110(%rsp)
xorpd %xmm1, %xmm1
movupd %xmm1, 0x140(%rsp)
movaps 0x40(%rsp), %xmm0
movaps %xmm0, 0x180(%rsp)
movq %r15, 0x150(%rsp)
movq %r14, 0x190(%rsp)
movq 0x158(%rsp), %rsi
movq %rsi, 0x198(%rsp)
movq 0x160(%rsp), %rsi
movq %rsi, 0x1a0(%rsp)
movupd %xmm1, 0x168(%rsp)
movaps 0x100(%rsp), %xmm0
movapd %xmm1, 0x100(%rsp)
movups %xmm0, 0x1a8(%rsp)
movq %r15, 0x178(%rsp)
movq %rdx, 0x1b8(%rsp)
movq %rax, 0x1c0(%rsp)
movq %rcx, 0x1c8(%rsp)
leaq 0xd8(%rsp), %rbx
movq %rbx, %rdi
movq 0x2d0(%rsp), %rsi
movl $0x4009, %edx # imm = 0x4009
callq 0x139bb0
movq (%rbx), %rsi
addq $0x8, %rsi
leaq 0xe0(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1400a0
movaps 0x180(%rsp), %xmm0
xorpd %xmm1, %xmm1
movapd %xmm1, 0x180(%rsp)
leaq 0x1d0(%rsp), %rsi
movaps %xmm0, (%rsi)
movq 0x190(%rsp), %rax
movq %r15, 0x190(%rsp)
movq %rax, 0x10(%rsi)
movups 0x198(%rsp), %xmm0
movups %xmm0, 0x18(%rsi)
movups 0x1a8(%rsp), %xmm0
movupd %xmm1, 0x1a8(%rsp)
movups %xmm0, 0x28(%rsi)
movq 0x1b8(%rsp), %rax
movq %r15, 0x1b8(%rsp)
movq %rax, 0x38(%rsi)
movaps 0x1c0(%rsp), %xmm0
movaps %xmm0, 0x40(%rsi)
movaps (%rbx), %xmm0
movapd %xmm1, (%rbx)
movaps %xmm0, 0x50(%rsi)
movq 0x10(%rbx), %rax
movq %r15, 0x10(%rbx)
movq %rax, 0x60(%rsi)
leaq 0xc0(%rsp), %rbx
movq %r15, 0x10(%rbx)
movapd %xmm1, (%rbx)
leaq 0x238(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4bed02
movupd (%r14), %xmm0
movupd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rbp, %rdx
movq 0x38(%rsp), %rcx
movq %r13, %r8
callq 0x148540
movq (%rbx), %rax
testq %rax, %rax
je 0x4bd640
lock
decl (%rax)
jne 0x4bd640
movq 0xc0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x1d0(%rsp), %rdi
callq 0x4beda2
movq 0xe0(%rsp), %rax
testq %rax, %rax
je 0x4bd676
lock
decl (%rax)
jne 0x4bd676
movq 0xe0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0xd8(%rsp), %rdi
callq 0x138860
leaq 0x180(%rsp), %rdi
callq 0x1a62f4
leaq 0x140(%rsp), %rdi
callq 0x1a62f4
movq 0x100(%rsp), %rax
testq %rax, %rax
movq 0x20(%rsp), %rbx
movq 0x2d0(%rsp), %r15
je 0x4bd6d3
lock
decl (%rax)
jne 0x4bd6d3
movq 0x100(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x120(%rsp), %rax
testq %rax, %rax
je 0x4bd6fc
lock
decl (%rax)
jne 0x4bd6fc
movq 0x120(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x268(%rsp), %rax
testq %rax, %rax
je 0x4bd725
lock
decl (%rax)
jne 0x4bd725
movq 0x268(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq %rbx, %rdi
movl $0x4812, %esi # imm = 0x4812
callq 0x146b30
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
movl $0x4103, %esi # imm = 0x4103
callq 0x146b30
addsd 0x18(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4bd92d
movsd %xmm0, 0x38(%rsp)
movq %rbx, %rdi
movl $0x4813, %esi # imm = 0x4813
callq 0x146b30
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4bd839
jp 0x4bd839
movq %rbx, %rdi
movl $0x4814, %esi # imm = 0x4814
callq 0x146b30
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4bd839
jp 0x4bd839
movq %rbx, %rdi
movl $0x4815, %esi # imm = 0x4815
callq 0x146b30
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4bd839
jp 0x4bd839
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rbx
movq 0x58(%rax), %r15
orq %r12, %r15
leaq 0xee8a5(%rip), %rdx # 0x5ac07c
leaq 0x1d0(%rsp), %r14
movl $0x7, %esi
movq %r14, %rdi
callq 0x143140
movq %r12, %rbp
movq 0x8(%r14), %r12
movq 0x10(%r14), %r14
orq %rbp, %r14
leaq 0x180(%rsp), %r13
movq %r13, %rdi
movsd 0x38(%rsp), %xmm0
callq 0x4b7231
movq 0x8(%r13), %rax
movq %rax, 0xb0(%rsp)
movq 0x10(%r13), %rax
orq %rbp, %rax
movq %rax, 0xb8(%rsp)
movupd 0xb0(%rsp), %xmm0
jmp 0x4bdc2e
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rbx
movq 0x58(%rax), %r15
orq %r12, %r15
leaq 0x101a50(%rip), %rdx # 0x5bf2a0
leaq 0x1d0(%rsp), %r14
movl $0xb, %esi
movq %r14, %rdi
callq 0x143140
movq %r12, %rbp
movq 0x8(%r14), %r12
movq 0x10(%r14), %r14
orq %rbp, %r14
leaq 0x180(%rsp), %r13
movq %r13, %rdi
movsd 0x38(%rsp), %xmm0
callq 0x4b7231
movq 0x8(%r13), %rax
movq %rax, 0xa0(%rsp)
movq 0x10(%r13), %rax
orq %rbp, %rax
movq %rax, 0xa8(%rsp)
movupd 0xa0(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x148540
movq (%r13), %rax
testq %rax, %rax
je 0x4bd8ed
lock
decl (%rax)
jne 0x4bd8ed
movq 0x180(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x1d0(%rsp), %rax
testq %rax, %rax
movq 0x2d0(%rsp), %r15
je 0x4bd91e
lock
decl (%rax)
jne 0x4bd91e
movq 0x1d0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl $0x4813, %esi # imm = 0x4813
callq 0x146b30
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
movl $0x4103, %esi # imm = 0x4103
callq 0x146b30
addsd 0x18(%rsp), %xmm0
ucomisd 0xc4acd(%rip), %xmm0 # 0x582428
jbe 0x4bda5b
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rbx
movq 0x58(%rax), %r15
orq %r12, %r15
leaq 0x101934(%rip), %rdx # 0x5bf2ac
leaq 0x1d0(%rsp), %r14
movl $0xe, %esi
movq %r14, %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x143140
movq %r12, %rbp
movq 0x8(%r14), %r12
movq 0x10(%r14), %r14
orq %rbp, %r14
leaq 0x180(%rsp), %r13
movq %r13, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x4b7231
movq 0x8(%r13), %rax
movq %rax, 0x90(%rsp)
movq 0x10(%r13), %rax
orq %rbp, %rax
movq %rax, 0x98(%rsp)
movupd 0x90(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x148540
movq (%r13), %rax
testq %rax, %rax
je 0x4bda1b
lock
decl (%rax)
jne 0x4bda1b
movq 0x180(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x1d0(%rsp), %rax
testq %rax, %rax
je 0x4bda44
lock
decl (%rax)
jne 0x4bda44
movq 0x1d0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
movq 0x20(%rsp), %rbx
movq 0x2d0(%rsp), %r15
movq %rbx, %rdi
movl $0x4814, %esi # imm = 0x4814
callq 0x146b30
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
movl $0x4103, %esi # imm = 0x4103
callq 0x146b30
addsd 0x18(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4bdb89
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rbx
movq 0x58(%rax), %r15
orq %r12, %r15
leaq 0x101815(%rip), %rdx # 0x5bf2bb
leaq 0x1d0(%rsp), %r14
movl $0xc, %esi
movq %r14, %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x143140
movq %r12, %rbp
movq 0x8(%r14), %r12
movq 0x10(%r14), %r14
orq %rbp, %r14
leaq 0x180(%rsp), %r13
movq %r13, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x4b7231
movq 0x8(%r13), %rax
movq %rax, 0x80(%rsp)
movq 0x10(%r13), %rax
orq %rbp, %rax
movq %rax, 0x88(%rsp)
movupd 0x80(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x148540
movq (%r13), %rax
testq %rax, %rax
je 0x4bdb49
lock
decl (%rax)
jne 0x4bdb49
movq 0x180(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x1d0(%rsp), %rax
testq %rax, %rax
je 0x4bdb72
lock
decl (%rax)
jne 0x4bdb72
movq 0x1d0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
movq 0x20(%rsp), %rbx
movq 0x2d0(%rsp), %r15
movq %rbx, %rdi
movl $0x4815, %esi # imm = 0x4815
callq 0x146b30
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
movl $0x4103, %esi # imm = 0x4103
callq 0x146b30
addsd 0x18(%rsp), %xmm0
ucomisd 0xc4871(%rip), %xmm0 # 0x582428
jbe 0x4bdca6
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rbx
movq 0x58(%rax), %r15
orq %r12, %r15
leaq 0x1016f4(%rip), %rdx # 0x5bf2c8
leaq 0x1d0(%rsp), %r14
movl $0xd, %esi
movq %r14, %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x143140
movq %r12, %rbp
movq 0x8(%r14), %r12
movq 0x10(%r14), %r14
orq %rbp, %r14
leaq 0x180(%rsp), %r13
movq %r13, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x4b7231
movq 0x8(%r13), %rax
movq %rax, 0x70(%rsp)
movq 0x10(%r13), %rax
orq %rbp, %rax
movq %rax, 0x78(%rsp)
movupd 0x70(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x148540
movq (%r13), %rax
testq %rax, %rax
je 0x4bdc6e
lock
decl (%rax)
jne 0x4bdc6e
movq 0x180(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x1d0(%rsp), %rax
testq %rax, %rax
je 0x4bdc97
lock
decl (%rax)
jne 0x4bdc97
movq 0x1d0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl $0x2021, %esi # imm = 0x2021
callq 0x1415c0
testb %al, %al
je 0x4bdddf
movq %rbx, %rdi
movl $0x2021, %esi # imm = 0x2021
callq 0x138f70
cmpl $0x5, %eax
je 0x4bdcf6
cmpl $0x4, %eax
je 0x4bdce0
cmpl $0x3, %eax
jne 0x4bdd0c
leaq 0xede93(%rip), %rdx # 0x5abb71
jmp 0x4bdcfd
leaq 0x1015c1(%rip), %rdx # 0x5bf2a8
leaq 0x1d0(%rsp), %r14
movl $0x3, %esi
jmp 0x4bdd20
leaq 0x1015b7(%rip), %rdx # 0x5bf2b4
leaq 0x1d0(%rsp), %r14
movl $0x6, %esi
jmp 0x4bdd20
leaq 0x1015c3(%rip), %rdx # 0x5bf2d6
leaq 0x1d0(%rsp), %r14
movl $0x9, %esi
movq %r14, %rdi
callq 0x143140
movq (%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r14), %r13
movq 0x10(%r14), %rbp
movq 0x30(%rsp), %rax
movq 0x38(%rax), %r14
movq 0x40(%rax), %r15
orq %r12, %r15
leaq 0xf1ad1(%rip), %rdx # 0x5af820
movq %r12, %rbx
leaq 0x1d0(%rsp), %r12
movl $0xe, %esi
movq %r12, %rdi
callq 0x143140
movq 0x8(%r12), %rcx
orq %rbx, %rbp
orq 0x10(%r12), %rbx
movq %r13, 0x60(%rsp)
movq %rbp, 0x68(%rsp)
movupd 0x60(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %r8
callq 0x148540
movq (%r12), %rax
testq %rax, %rax
je 0x4bddc1
lock
decl (%rax)
jne 0x4bddc1
movq 0x1d0(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4bdddf
lock
decl (%rdi)
jne 0x4bdddf
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x28(%rsp), %rdi
callq 0x143060
movq %fs:0x28, %rax
cmpq 0x290(%rsp), %rax
jne 0x4bde0e
addq $0x298, %rsp # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/text/qtextodfwriter.cpp |
QHash<int, QList<int>>::value(int const&) const | T value(const Key &key) const noexcept
{
if (T *v = valueImpl(key))
return *v;
else
return T();
} | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x4becee
movq %rdx, %rsi
callq 0x4bf964
testq %rax, %rax
je 0x4becee
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
movq 0x10(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq 0x18(%rax), %rax
movq %rax, 0x10(%rbx)
testq %rcx, %rcx
je 0x4becfc
lock
incl (%rcx)
jmp 0x4becfc
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
| /qt[P]qtbase/src/corelib/tools/qhash.h |
void QConcatenable<QStringBuilder<QStringBuilder<QStringBuilder<QStringBuilder<QString, QLatin1String>, QString>, QLatin1String>, QString>>::appendTo<QChar>(QStringBuilder<QStringBuilder<QStringBuilder<QStringBuilder<QString, QLatin1String>, QString>, QLatin1String>, QString> const&, QChar*&) | static inline void appendTo(const type &p, T *&out)
{
QConcatenableEx<A>::appendTo(p.a, out);
QConcatenableEx<B>::appendTo(p.b, out);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0x4bf4fb
movq (%rbx), %rdi
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x4bf4f2
movq 0x22fa56(%rip), %rsi # 0x6eef48
leaq (%r12,%r12), %rdx
callq 0x137aa0
addq %r12, %r12
addq (%rbx), %r12
movq %r12, (%rbx)
movq 0x18(%r14), %r15
movq 0x20(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x146510
addq %r15, %r15
addq (%rbx), %r15
movq %r15, (%rbx)
movq 0x38(%r14), %r12
testq %r12, %r12
je 0x4bf548
movq 0x30(%r14), %rsi
testq %rsi, %rsi
jne 0x4bf539
movq 0x22fa0f(%rip), %rsi # 0x6eef48
leaq (%r12,%r12), %rdx
movq %r15, %rdi
callq 0x137aa0
movq (%rbx), %r15
leaq (%r15,%r12,2), %rdx
movq %rdx, (%rbx)
movq 0x40(%r14), %r15
movq 0x48(%r14), %rsi
movq %r15, %rdi
callq 0x146510
addq %r15, %r15
addq (%rbx), %r15
movq %r15, (%rbx)
movq 0x60(%r14), %r12
testq %r12, %r12
je 0x4bf590
movq 0x58(%r14), %rsi
testq %rsi, %rsi
jne 0x4bf581
movq 0x22f9c7(%rip), %rsi # 0x6eef48
leaq (%r12,%r12), %rdx
movq %r15, %rdi
callq 0x137aa0
movq (%rbx), %r15
leaq (%r15,%r12,2), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /qt[P]qtbase/src/corelib/text/qstringbuilder.h |
QHash<int, QList<int>>::iterator QHash<int, QList<int>>::emplace_helper<QList<int>>(int&&, QList<int>&&) | iterator emplace_helper(Key &&key, Args &&... args)
{
auto result = d->findOrInsert(key);
if (!result.initialized)
Node::createInPlace(result.it.node(), std::move(key), std::forward<Args>(args)...);
else
result.it.node()->emplaceValue(std::forward<Args>(args)...);
return iterator(result.it);
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r15
movq %rax, 0x10(%r15)
movaps 0xb43cd(%rip), %xmm0 # 0x574680
movaps %xmm0, (%r15)
movq (%rdi), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4c0430
movq (%r15), %rax
movq 0x8(%r15), %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
movzbl (%rcx,%rsi), %edi
shll $0x5, %edi
addq 0x80(%rax,%rdx), %rdi
cmpb $0x0, 0x10(%r15)
je 0x4c0306
movq %rbx, %rsi
callq 0x4c0532
jmp 0x4c032f
movl (%r14), %eax
movl %eax, (%rdi)
movq (%rbx), %rax
xorl %ecx, %ecx
movq %rcx, (%rbx)
movq %rax, 0x8(%rdi)
movq 0x8(%rbx), %rax
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rdi)
movq 0x10(%rbx), %rax
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rdi)
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
movq %fs:0x28, %rcx
cmpq 0x18(%rsp), %rcx
jne 0x4c0352
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/tools/qhash.h |
QHashPrivate::Span<QHashPrivate::Node<int, QList<int>>>::insert(unsigned long) | Node *insert(size_t i)
{
Q_ASSERT(i < SpanConstants::NEntries);
Q_ASSERT(offsets[i] == SpanConstants::UnusedEntry);
if (nextFree == allocated)
addStorage();
unsigned char entry = nextFree;
Q_ASSERT(entry < allocated);
nextFree = entries[entry].nextFree();
offsets[i] = entry;
return &entries[entry].node();
} | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x89(%rdi), %al
cmpb 0x88(%rdi), %al
jne 0x4c0864
movq %rbx, %rdi
callq 0x4c0890
movb 0x89(%rbx), %al
movq 0x80(%rbx), %rcx
movzbl %al, %edx
movl %edx, %eax
shll $0x5, %eax
movb (%rcx,%rax), %cl
movb %cl, 0x89(%rbx)
movb %dl, (%rbx,%r14)
addq 0x80(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /qt[P]qtbase/src/corelib/tools/qhash.h |
CbDebugLog(char const*, void*) | static void CbDebugLog(const char *msg, void *userdata)
{
Q_UNUSED(userdata);
qCDebug(lcMD) << msg;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
callq 0x4c19a3
movb 0x24b839(%rip), %al # 0x70d108
testb $0x1, %al
je 0x4c1984
movq 0x24b822(%rip), %rax # 0x70d100
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x13ecf0
movq (%r14), %r14
testq %rbx, %rbx
je 0x4c1927
movq $-0x1, %rax
leaq 0x1(%rax), %rsi
cmpb $0x0, 0x1(%rbx,%rax)
movq %rsi, %rax
jne 0x4c1917
jmp 0x4c1929
xorl %esi, %esi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1457d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x4c1965
lock
decl (%rax)
jne 0x4c1965
movq 0x30(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x28(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x4c197a
movl $0x20, %esi
callq 0x13d680
leaq 0x28(%rsp), %rdi
callq 0x1391b0
movq %fs:0x28, %rax
cmpq 0x48(%rsp), %rax
jne 0x4c199e
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/text/qtextmarkdownimporter.cpp |
QTextMarkdownImporter::cbLeaveSpan(int, void*) | int QTextMarkdownImporter::cbLeaveSpan(int spanType, void *detail)
{
Q_UNUSED(detail);
QTextCharFormat charFmt;
if (!m_spanFormatStack.isEmpty()) {
m_spanFormatStack.pop();
if (!m_spanFormatStack.isEmpty())
charFmt = m_spanFormatStack.top();
}
m_cursor.setCharFormat(charFmt);
qCDebug(lcMD) << spanType << "setCharFormat" << charFmt.font().families().constFirst()
<< charFmt.fontWeight() << (charFmt.fontItalic() ? "italic" : "")
<< charFmt.foreground().color().name();
if (spanType == int(MD_SPAN_IMG))
m_imageSpan = false;
return 0; // no error
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x90(%rsp)
movaps 0xb0df2(%rip), %xmm0 # 0x574680
leaq 0x80(%rsp), %rdi
movaps %xmm0, (%rdi)
callq 0x13c710
cmpq $0x0, 0x80(%rbx)
je 0x4c38e7
leaq 0x70(%rbx), %r14
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c5c16
movq %r15, %rdi
callq 0x13c1a0
cmpq $0x0, 0x80(%rbx)
je 0x4c38e7
movq %r14, %rdi
callq 0x4c5820
leaq -0x10(%rax), %rsi
leaq 0x80(%rsp), %rdi
callq 0x13c1d0
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x139bf0
callq 0x4c19a3
movb 0x249806(%rip), %al # 0x70d108
testb $0x1, %al
je 0x4c3b9c
movq 0x2497ef(%rip), %rax # 0x70d100
leaq 0x20(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x13ecf0
movq (%r14), %rdi
movl %ebp, %esi
callq 0x147670
movq (%r14), %r14
cmpb $0x1, 0x30(%r14)
jne 0x4c3961
movq %r14, %rdi
movl $0x20, %esi
callq 0x13d680
movq 0x40(%rsp), %r14
leaq 0xfbf9f(%rip), %rdx # 0x5bf907
leaq 0x48(%rsp), %r15
movl $0xd, %esi
movq %r15, %rdi
callq 0x1457d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x4c39a6
lock
decl (%rax)
jne 0x4c39a6
movq 0x48(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x40(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x4c39bb
movl $0x20, %esi
callq 0x13d680
leaq 0x60(%rsp), %r14
leaq 0x80(%rsp), %rsi
movq %r14, %rdi
callq 0x13e3a0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x144360
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
testq %rsi, %rsi
jne 0x4c39f8
movq 0x22b550(%rip), %rsi # 0x6eef48
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x137cf0
movq (%r14), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x4c3a18
movl $0x20, %esi
callq 0x13d680
leaq 0x80(%rsp), %rdi
movl $0x2003, %esi # imm = 0x2003
callq 0x1415c0
movl $0x190, %esi # imm = 0x190
testb %al, %al
je 0x4c3a47
leaq 0x80(%rsp), %rdi
movl $0x2003, %esi # imm = 0x2003
callq 0x138f70
movl %eax, %esi
movq 0x40(%rsp), %rdi
callq 0x147670
movq 0x40(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x4c3a66
movl $0x20, %esi
callq 0x13d680
leaq 0x80(%rsp), %rdi
movl $0x2004, %esi # imm = 0x2004
callq 0x148c30
leaq 0xe7f30(%rip), %rcx # 0x5ab9af
leaq 0xb46eb(%rip), %rdx # 0x578171
testb %al, %al
cmovneq %rcx, %rdx
movq 0x40(%rsp), %r14
movq $-0x1, %rsi
cmpb $0x0, 0x1(%rdx,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x4c3a98
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x1457d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x4c3adc
lock
decl (%rax)
jne 0x4c3adc
movq 0x48(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x40(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x4c3af1
movl $0x20, %esi
callq 0x13d680
movq %rsp, %r14
leaq 0x80(%rsp), %rsi
movq %r14, %rdi
movl $0x821, %edx # imm = 0x821
callq 0x139bb0
movq (%r14), %rsi
addq $0x8, %rsi
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x1400a0
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
testq %rsi, %rsi
jne 0x4c3b33
movq 0x22b415(%rip), %rsi # 0x6eef48
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x137cf0
movq (%r14), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x4c3b53
movl $0x20, %esi
callq 0x13d680
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0x4c3b76
lock
decl (%rax)
jne 0x4c3b76
movq 0x48(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq %rsp, %rdi
callq 0x138860
leaq 0x8(%rsp), %rdi
callq 0x17ddb4
leaq 0x60(%rsp), %rdi
callq 0x146e80
leaq 0x40(%rsp), %rdi
callq 0x1391b0
cmpl $0x3, %ebp
jne 0x4c3ba8
movb $0x0, 0xf8(%rbx)
leaq 0x80(%rsp), %rdi
callq 0x13c1a0
movq %fs:0x28, %rax
cmpq 0x90(%rsp), %rax
jne 0x4c3bd8
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/text/qtextmarkdownimporter.cpp |
QTextMarkdownImporter::insertBlock() | void QTextMarkdownImporter::insertBlock()
{
QTextCharFormat charFormat;
if (!m_spanFormatStack.isEmpty())
charFormat = m_spanFormatStack.top();
QTextBlockFormat blockFormat;
if (!m_listStack.isEmpty() && !m_needsInsertList && m_listItem) {
QTextList *list = m_listStack.top();
if (list)
blockFormat = list->item(list->count() - 1).blockFormat();
else
qWarning() << "attempted to insert into a list that no longer exists";
}
if (m_blockQuoteDepth) {
blockFormat.setProperty(QTextFormat::BlockQuoteLevel, m_blockQuoteDepth);
blockFormat.setLeftMargin(qtmi_BlockQuoteIndent * m_blockQuoteDepth);
blockFormat.setRightMargin(qtmi_BlockQuoteIndent);
}
if (m_codeBlock) {
blockFormat.setProperty(QTextFormat::BlockCodeLanguage, m_blockCodeLanguage);
if (m_blockCodeFence) {
blockFormat.setNonBreakableLines(true);
blockFormat.setProperty(QTextFormat::BlockCodeFence, QString(QLatin1Char(m_blockCodeFence)));
}
charFormat.setFont(m_monoFont);
} else {
blockFormat.setTopMargin(m_paragraphMargin);
blockFormat.setBottomMargin(m_paragraphMargin);
}
if (m_markerType == QTextBlockFormat::MarkerType::NoMarker)
blockFormat.clearProperty(QTextFormat::BlockMarker);
else
blockFormat.setMarker(m_markerType);
if (!m_listStack.isEmpty())
blockFormat.setIndent(m_listStack.size());
if (m_cursor.document()->isEmpty()) {
m_cursor.setBlockFormat(blockFormat);
m_cursor.setCharFormat(charFormat);
} else if (m_listItem) {
m_cursor.insertBlock(blockFormat, QTextCharFormat());
m_cursor.setCharFormat(charFormat);
} else {
m_cursor.insertBlock(blockFormat, charFormat);
}
if (m_needsInsertList) {
m_listStack.push(m_cursor.createList(m_listFormat));
} else if (!m_listStack.isEmpty() && m_listItem && m_listStack.top()) {
m_listStack.top()->add(m_cursor.block());
}
m_needsInsertList = false;
m_needsInsertBlock = false;
} | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x68(%rsp)
movaps 0xafa85(%rip), %xmm0 # 0x574680
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
callq 0x13c710
cmpq $0x0, 0x80(%rbx)
je 0x4c4c29
leaq 0x70(%rbx), %rdi
callq 0x4c5820
leaq -0x10(%rax), %rsi
leaq 0x30(%rsp), %rdi
callq 0x13c1d0
leaq 0x20(%rsp), %rdi
movapd 0xafa4a(%rip), %xmm0 # 0x574680
movapd %xmm0, (%rdi)
callq 0x139640
leaq 0x58(%rbx), %r14
cmpq $0x0, 0x68(%rbx)
je 0x4c4cc9
cmpb $0x0, 0xf5(%rbx)
jne 0x4c4cc9
cmpb $0x1, 0xf6(%rbx)
jne 0x4c4cc9
movq %r14, %rdi
callq 0x4c5272
movq -0x10(%rax), %rcx
testq %rcx, %rcx
je 0x4c50a3
movl 0x4(%rcx), %ecx
testl %ecx, %ecx
je 0x4c50a3
movq -0x8(%rax), %r15
testq %r15, %r15
je 0x4c50a3
movq %r15, %rdi
callq 0x1453d0
leal -0x1(%rax), %edx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1484b0
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x13cfc0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x13c1d0
movq %r15, %rdi
callq 0x13c1a0
movl 0xac(%rbx), %esi
testl %esi, %esi
je 0x4c4d66
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x137320
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl $0x1080, %esi # imm = 0x1080
movq %r12, %rdx
callq 0x148430
movq %r12, %rdi
callq 0x13e600
movl 0xac(%rbx), %eax
shll $0x3, %eax
leal (%rax,%rax,4), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x1450c0
movq %r15, %rdi
movl $0x1032, %esi # imm = 0x1032
movq %r12, %rdx
callq 0x148430
movq %r12, %rdi
callq 0x13e600
leaq 0x48(%rsp), %r12
movsd 0xfa9b2(%rip), %xmm0 # 0x5bf6f8
movq %r12, %rdi
callq 0x1450c0
movq %r15, %rdi
movl $0x1033, %esi # imm = 0x1033
movq %r12, %rdx
callq 0x148430
movq %r12, %rdi
callq 0x13e600
cmpb $0x1, 0xf7(%rbx)
jne 0x4c4e4f
leaq 0x28(%rbx), %rsi
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x1409e0
leaq 0x20(%rsp), %rdi
movl $0x1090, %esi # imm = 0x1090
movq %r15, %rdx
callq 0x148430
movq %r15, %rdi
callq 0x13e600
cmpb $0x0, 0xc4(%rbx)
je 0x4c4e37
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
callq 0x1375c0
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movl $0x1050, %esi # imm = 0x1050
movq %r15, %rdx
callq 0x148430
movq %r15, %rdi
callq 0x13e600
movzbl 0xc4(%rbx), %esi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x148840
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x1409e0
movq %r12, %rdi
movl $0x1091, %esi # imm = 0x1091
movq %r13, %rdx
callq 0x148430
movq %r13, %rdi
callq 0x13e600
movq (%r15), %rax
testq %rax, %rax
je 0x4c4e37
lock
decl (%rax)
jne 0x4c4e37
movq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x88(%rbx), %rsi
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
callq 0x139230
jmp 0x4c4eb4
xorps %xmm0, %xmm0
cvtsi2sdl 0xbc(%rbx), %xmm0
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x1450c0
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movl $0x1030, %esi # imm = 0x1030
movq %r15, %rdx
callq 0x148430
movq %r15, %rdi
callq 0x13e600
xorps %xmm0, %xmm0
cvtsi2sdl 0xbc(%rbx), %xmm0
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x1450c0
movq %r12, %rdi
movl $0x1031, %esi # imm = 0x1031
movq %r15, %rdx
callq 0x148430
movq %r15, %rdi
callq 0x13e600
movl 0xf0(%rbx), %esi
testl %esi, %esi
je 0x4c4ee7
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x137320
leaq 0x20(%rsp), %rdi
movl $0x10a0, %esi # imm = 0x10A0
movq %r15, %rdx
callq 0x148430
movq %r15, %rdi
callq 0x13e600
jmp 0x4c4ef6
leaq 0x20(%rsp), %rdi
movl $0x10a0, %esi # imm = 0x10A0
callq 0x13e2f0
movq 0x68(%rbx), %rsi
testq %rsi, %rsi
je 0x4c4f26
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x137320
leaq 0x20(%rsp), %rdi
movl $0x1040, %esi # imm = 0x1040
movq %r15, %rdx
callq 0x148430
movq %r15, %rdi
callq 0x13e600
movq %rbx, %rdi
callq 0x1411e0
movq %rax, %rdi
callq 0x13d860
testb %al, %al
je 0x4c4f49
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1451c0
jmp 0x4c4f77
cmpb $0x1, 0xf6(%rbx)
jne 0x4c4f86
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x13c710
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1457c0
movq %r15, %rdi
callq 0x13c1a0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x139bf0
jmp 0x4c4f98
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x1457c0
cmpb $0x1, 0xf5(%rbx)
jne 0x4c4fc2
leaq 0xe0(%rbx), %rsi
movq %rbx, %rdi
callq 0x139610
movq %rax, %r15
testq %rax, %rax
je 0x4c5022
movq %r15, %rdi
callq 0x13a440
jmp 0x4c5024
cmpq $0x0, 0x68(%rbx)
je 0x4c5068
cmpb $0x1, 0xf6(%rbx)
jne 0x4c5068
movq %r14, %rdi
callq 0x4c5272
movq -0x10(%rax), %rcx
testq %rcx, %rcx
je 0x4c5068
movl 0x4(%rcx), %ecx
testl %ecx, %ecx
je 0x4c5068
cmpq $0x0, -0x8(%rax)
je 0x4c5068
movq %r14, %rdi
callq 0x4c5272
movq -0x10(%rax), %rcx
testq %rcx, %rcx
je 0x4c50ad
movl 0x4(%rcx), %ecx
testl %ecx, %ecx
je 0x4c50ad
movq -0x8(%rax), %r14
jmp 0x4c50b0
xorl %eax, %eax
leaq 0x48(%rsp), %r12
movq %rax, (%r12)
movq %r15, 0x8(%r12)
movq 0x68(%rbx), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x4c5116
movq %r14, %rdi
callq 0x4c5272
movq (%r12), %rax
testq %rax, %rax
je 0x4c5068
lock
decl (%rax)
jne 0x4c5068
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
jne 0x4c5063
xorl %edi, %edi
callq 0x13df00
movw $0x0, 0xf4(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x13c1a0
leaq 0x30(%rsp), %rdi
callq 0x13c1a0
movq %fs:0x28, %rax
cmpq 0x68(%rsp), %rax
jne 0x4c50cd
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x161b48
jmp 0x4c4cc9
xorl %r14d, %r14d
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13b820
movq %r14, %rdi
movq %r15, %rsi
callq 0x145090
jmp 0x4c5068
callq 0x13a8c0
| /qt[P]qtbase/src/gui/text/qtextmarkdownimporter.cpp |
QArrayDataPointer<QPointer<QTextList>>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QPointer<QTextList> const**) | qsizetype constAllocatedCapacity() const noexcept { return d ? d->constAllocatedCapacity() : 0; } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x4c5384
movq 0x8(%rax), %r9
movq 0x8(%rdi), %r8
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %r8
sarq $0x4, %r8
movq 0x10(%rdi), %rax
addq %r8, %rax
movq %r9, %r10
subq %rax, %r10
jmp 0x4c538d
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %esi, %esi
jne 0x4c53a9
cmpq %rdx, %r8
jl 0x4c53a9
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rdx
addq %r9, %r9
xorl %eax, %eax
cmpq %r9, %rdx
jl 0x4c53e1
retq
xorl %eax, %eax
cmpl $0x1, %esi
jne 0x4c53a8
cmpq %rdx, %r10
jl 0x4c53a8
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rsi
cmpq %r9, %rsi
jge 0x4c53f7
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 0x4c55e6
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QList<QTextCharFormat>::end() | iterator end() { detach(); return iterator(d->end()); } | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x4c5837
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x4c5845
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3b94b8
movq 0x10(%rbx), %rax
shlq $0x4, %rax
addq 0x8(%rbx), %rax
popq %rbx
retq
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QArrayDataPointer<QTextCharFormat>::detachAndGrow(QArrayData::GrowthPosition, long long, QTextCharFormat const**, QArrayDataPointer<QTextCharFormat>*) | void detachAndGrow(QArrayData::GrowthPosition where, qsizetype n, const T **data,
QArrayDataPointer *old)
{
const bool detach = needsDetach();
bool readjusted = false;
if (!detach) {
if (!n || (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= 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 0x4c5a07
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x4c5a21
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b94b8
testq %r14, %r14
je 0x4c5a82
testl %ebp, %ebp
je 0x4c5a4e
cmpl $0x1, %ebp
jne 0x4c5a47
movq 0x8(%r15), %rdx
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %r14, %rdx
jge 0x4c5a82
movq %r15, %rdi
movl %ebp, %esi
jmp 0x4c5a76
movq 0x8(%rax), %rdx
movq 0x8(%r15), %rsi
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rsi
sarq $0x4, %rsi
addq 0x10(%r15), %rsi
subq %rsi, %rdx
cmpq %r14, %rdx
jge 0x4c5a82
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x4c5adc
testb %al, %al
je 0x4c5a07
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
void QtPrivate::q_relocate_overlap_n<QTextCharFormat, long long>(QTextCharFormat*, long long, QTextCharFormat*) | void q_relocate_overlap_n(T *first, N n, T *d_first)
{
static_assert(std::is_nothrow_destructible_v<T>,
"This algorithm requires that T has a non-throwing destructor");
if (n == N(0) || first == d_first || first == nullptr || d_first == nullptr)
return;
if constexpr (QTypeInfo<T>::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 0x4c5c15
testq %rdx, %rdx
je 0x4c5c15
movq %rdi, %rsi
testq %rdi, %rdi
je 0x4c5c15
cmpq %rdx, %rsi
je 0x4c5c15
shlq $0x4, %rax
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x138810
retq
| /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QString QStringBuilder<QStringBuilder<char16_t, QString const&>, char16_t>::convertTo<QString>() const | T convertTo() const
{
if (isNull()) {
// appending two null strings must give back a null string,
// so we're special casing this one out, QTBUG-114206
return T();
}
const qsizetype len = Concatenable::size(*this);
T s(len, Qt::Uninitialized);
// Using data_ptr() here (private API) so we can bypass the
// isDetached() and the replacement of a null pointer with _empty in
// both QString and QByteArray's data() and constData(). The result is
// the same if len != 0.
auto d = reinterpret_cast<typename T::iterator>(s.data_ptr().data());
const auto start = d;
Concatenable::appendTo(*this, d);
if constexpr (Concatenable::ExactSize) {
Q_UNUSED(start)
} else {
if (len != d - start) {
// this resize is necessary since we allocate a bit too much
// when dealing with variable sized 8-bit encodings
s.resize(d - start);
}
}
return s;
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x10(%rax), %rsi
addq $0x2, %rsi
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x10(%rdi)
movaps 0xa04c5(%rip), %xmm0 # 0x574680
movups %xmm0, (%rdi)
xorl %edx, %edx
callq 0x142b80
movq 0x8(%rbx), %r15
movzwl (%r14), %eax
movw %ax, (%r15)
addq $0x2, %r15
movq 0x8(%r14), %rax
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x4d41fe
movq 0x8(%rax), %rsi
testq %rsi, %rsi
jne 0x4d41f2
movq 0x21ad56(%rip), %rsi # 0x6eef48
leaq (%r12,%r12), %rdx
movq %r15, %rdi
callq 0x137aa0
movzwl 0x10(%r14), %eax
movw %ax, (%r15,%r12,2)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /qt[P]qtbase/src/corelib/text/qstringbuilder.h |
QCss::ValueExtractor::extractPosition(int*, int*, int*, int*, QCss::Origin*, QFlags<Qt::AlignmentFlag>*, QCss::PositionMode*, QFlags<Qt::AlignmentFlag>*) | bool ValueExtractor::extractPosition(int *left, int *top, int *right, int *bottom, QCss::Origin *origin,
Qt::Alignment *position, QCss::PositionMode *mode, Qt::Alignment *textAlignment)
{
extractFont();
bool hit = false;
for (int i = 0; i < declarations.size(); i++) {
const Declaration &decl = declarations.at(i);
switch (decl.d->propertyId) {
case Left: *left = lengthValue(decl); break;
case Top: *top = lengthValue(decl); break;
case Right: *right = lengthValue(decl); break;
case Bottom: *bottom = lengthValue(decl); break;
case QtOrigin: *origin = decl.originValue(); break;
case QtPosition: *position = decl.alignmentValue(); break;
case TextAlignment: *textAlignment = decl.alignmentValue(); break;
case Position: *mode = decl.positionValue(); break;
default: continue;
}
hit = true;
}
return hit;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x2c(%rdi)
jne 0x4d8ab4
leaq 0x1c(%rsp), %rdx
movl $0xffffff01, (%rdx) # imm = 0xFFFFFF01
leaq 0x18(%rbp), %rsi
movq %rbp, %rdi
callq 0x149700
cmpq $0x0, 0x10(%rbp)
je 0x4d8b7b
xorl %ebx, %ebx
leaq 0xe8bbc(%rip), %r14 # 0x5c1684
xorl %r15d, %r15d
xorl %eax, %eax
movq 0x8(%rbp), %rsi
movq (%rsi,%rbx), %rcx
movl 0x20(%rcx), %ecx
addl $-0x4c, %ecx
cmpl $0xc, %ecx
ja 0x4d8b68
addq %rbx, %rsi
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movq %rbp, %rdi
callq 0x13de80
movl %eax, (%r13)
jmp 0x4d8b66
movq %rsi, %rdi
callq 0x145140
movq 0x60(%rsp), %rcx
jmp 0x4d8b64
movq %rbp, %rdi
callq 0x13de80
movq (%rsp), %rcx
jmp 0x4d8b64
movq %rsi, %rdi
callq 0x140940
movq 0x68(%rsp), %rcx
jmp 0x4d8b64
movq %rsi, %rdi
callq 0x145140
movq 0x70(%rsp), %rcx
jmp 0x4d8b64
movq %rbp, %rdi
callq 0x13de80
movl %eax, (%r12)
jmp 0x4d8b66
movq %rbp, %rdi
callq 0x13de80
movq 0x8(%rsp), %rcx
jmp 0x4d8b64
movq %rsi, %rdi
callq 0x13b0a0
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movb $0x1, %al
incq %r15
addq $0x8, %rbx
cmpq %r15, 0x10(%rbp)
ja 0x4d8acd
jmp 0x4d8b7d
xorl %eax, %eax
movq %fs:0x28, %rcx
cmpq 0x20(%rsp), %rcx
jne 0x4d8b9e
andb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/text/qcssparser.cpp |
QList<QFontVariableAxis>::end() | iterator end() { detach(); return iterator(d->end()); } | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x4f9425
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x4f9433
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4f95e4
movq 0x10(%rbx), %rax
shlq $0x3, %rax
addq 0x8(%rbx), %rax
popq %rbx
retq
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QUndoStack::redoText() const | QString QUndoStack::redoText() const
{
Q_D(const QUndoStack);
if (!d->macro_stack.isEmpty())
return QString();
if (d->index < d->command_list.size())
return d->command_list.at(d->index)->actionText();
return QString();
} | endbr64
movq %rdi, %rax
movq 0x8(%rsi), %rcx
cmpq $0x0, 0xa0(%rcx)
jne 0x503532
movslq 0xa8(%rcx), %rdx
cmpq %rdx, 0x88(%rcx)
jle 0x503532
movq 0x80(%rcx), %rcx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rcx), %rdx
movq 0x30(%rdx), %rcx
movq %rcx, (%rax)
movq 0x38(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq 0x40(%rdx), %rdx
movq %rdx, 0x10(%rax)
testq %rcx, %rcx
je 0x503531
lock
incl (%rcx)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
retq
nop
| /qt[P]qtbase/src/gui/util/qundostack.cpp |
QUndoStackPrivate::checkUndoLimit() | bool QUndoStackPrivate::checkUndoLimit()
{
if (undo_limit <= 0 || !macro_stack.isEmpty() || undo_limit >= command_list.size())
return false;
int del_count = command_list.size() - undo_limit;
for (int i = 0; i < del_count; ++i)
delete command_list.takeFirst();
index -= del_count;
if (clean_index != -1) {
if (clean_index < del_count)
clean_index = -1; // we've deleted the clean command
else
clean_index -= del_count;
}
return true;
} | endbr64
movslq 0xb8(%rdi), %rax
testq %rax, %rax
jle 0x50363c
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0xa0(%rdi)
jne 0x50362f
movq 0x88(%rbx), %r15
cmpq %rax, %r15
jbe 0x50362f
subl %eax, %r15d
testl %r15d, %r15d
jle 0x503608
leaq 0x78(%rbx), %r14
movl %r15d, %ebp
movq %r14, %rdi
callq 0x505e60
movq (%rax), %rdi
addq $0x8, 0x80(%rbx)
decq 0x88(%rbx)
testq %rdi, %rdi
je 0x503604
movq (%rdi), %rax
callq *0x8(%rax)
decl %ebp
jne 0x5035df
subl %r15d, 0xa8(%rbx)
movl 0xac(%rbx), %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
je 0x503631
subl %r15d, %ecx
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmovgel %ecx, %edx
movl %edx, 0xac(%rbx)
jmp 0x503631
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
nop
| /qt[P]qtbase/src/gui/util/qundostack.cpp |
QUndoStack::~QUndoStack() | QUndoStack::~QUndoStack()
{
#if QT_CONFIG(undogroup)
Q_D(QUndoStack);
if (d->group != nullptr)
d->group->removeStack(this);
#endif
clear();
} | endbr64
pushq %rbx
movq %rdi, %rbx
callq 0x1462d0
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x137fb0
nop
| /qt[P]qtbase/src/gui/util/qundostack.cpp |
QUndoGroup::~QUndoGroup() | QUndoGroup::~QUndoGroup()
{
// Ensure all QUndoStacks no longer refer to this group.
Q_D(QUndoGroup);
QList<QUndoStack *>::iterator it = d->stack_list.begin();
QList<QUndoStack *>::iterator end = d->stack_list.end();
while (it != end) {
(*it)->d_func()->group = nullptr;
++it;
}
} | endbr64
pushq %rbx
movq %rdi, %rbx
callq 0x144080
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x137fb0
nop
| /qt[P]qtbase/src/gui/util/qundogroup.cpp |
QUndoGroup::createUndoAction(QObject*, QString const&) const | QAction *QUndoGroup::createUndoAction(QObject *parent, const QString &prefix) const
{
QAction *action = new QAction(parent);
action->setEnabled(canUndo());
QString effectivePrefix = prefix;
QString defaultText;
if (prefix.isEmpty()) {
effectivePrefix = tr("Undo %1");
defaultText = tr("Undo", "Default text for undo action");
}
QUndoStackPrivate::setPrefixedText(action, effectivePrefix, defaultText, undoText());
connect(this, &QUndoGroup::canUndoChanged, action, &QAction::setEnabled);
connect(this, &QUndoGroup::undoTextChanged, action, [=](const QString &text) {
QUndoStackPrivate::setPrefixedText(action, effectivePrefix, defaultText, text);
});
connect(action, &QAction::triggered, this, &QUndoGroup::undo);
return action;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0xb0(%rsp)
movl $0x10, %edi
callq 0x1387d0
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
callq 0x148d90
movq %rbx, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x78(%rax), %rdi
testq %rdi, %rdi
je 0x5069a8
callq 0x13bab0
jmp 0x5069aa
xorl %eax, %eax
movzbl %al, %esi
movq %rbp, %rdi
callq 0x136d70
movq (%r15), %rcx
movq %rcx, 0x90(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x98(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0xa0(%rsp)
testq %rcx, %rcx
je 0x5069e4
lock
incl (%rcx)
movq 0x10(%r15), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movq $0x0, 0x80(%rsp)
testq %rax, %rax
je 0x506a22
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x78(%rax), %rsi
testq %rsi, %rsi
je 0x506b0d
leaq 0x50(%rsp), %rdi
callq 0x13cd00
jmp 0x506b1e
movq 0x1e90c7(%rip), %rsi # 0x6efaf0
leaq 0xbf60e(%rip), %rdx # 0x5c603e
leaq 0x50(%rsp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
callq 0x13dad0
movq 0x90(%rsp), %rax
movups 0x98(%rsp), %xmm0
movaps (%r15), %xmm1
movq %rax, (%r15)
movaps %xmm1, 0x90(%rsp)
movq 0x10(%r15), %rcx
movups %xmm0, 0x8(%r15)
movq %rcx, 0xa0(%rsp)
testq %rax, %rax
je 0x506a93
lock
decl (%rax)
jne 0x506a93
movq 0x50(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x1e9056(%rip), %rsi # 0x6efaf0
leaq 0xbf5a5(%rip), %rdx # 0x5c6046
leaq 0xbf5a3(%rip), %rcx # 0x5c604b
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
callq 0x13dad0
movq 0x70(%rsp), %rax
movups 0x78(%rsp), %xmm0
movaps (%r15), %xmm1
movq %rax, (%r15)
movaps %xmm1, 0x70(%rsp)
movq 0x10(%r15), %rcx
movups %xmm0, 0x8(%r15)
movq %rcx, 0x80(%rsp)
testq %rax, %rax
je 0x5069fd
lock
decl (%rax)
jne 0x5069fd
movq 0x50(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x5069fd
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %r15
movq %rbp, %rdi
movq %r15, %rcx
callq 0x5041a4
movq (%r15), %rax
testq %rax, %rax
je 0x506b5c
lock
decl (%rax)
jne 0x506b5c
movq 0x50(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x1e8d85(%rip), %rbx # 0x6ef8e8
leaq 0x38(%rsp), %r15
movq %rbx, (%r15)
xorl %r14d, %r14d
movq %r14, 0x8(%r15)
movq 0x1e86bf(%rip), %rax # 0x6ef238
leaq 0x50(%rsp), %r12
movq %rax, (%r12)
movq %r14, 0x8(%r12)
movl $0x20, %edi
callq 0x1387d0
movl $0x1, (%rax)
leaq -0xc88(%rip), %rcx # 0x505f16
movq %rcx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
subq $0x8, %rsp
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
movq %rbp, 0x28(%rsp)
movq %rbp, %rcx
movq %r15, %r8
movq %rax, %r9
pushq 0x1e8f1e(%rip) # 0x6efaf0
pushq %r14
pushq $0x0
callq 0x143f40
addq $0x20, %rsp
movq %r13, %rdi
callq 0x13f960
movq 0x90(%rsp), %r12
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
testq %r12, %r12
je 0x506c13
lock
incl (%r12)
movq 0x70(%rsp), %rbx
movq 0x78(%rsp), %r14
movq 0x80(%rsp), %rbp
testq %rbx, %rbx
je 0x506c2d
lock
incl (%rbx)
movq 0x1e8d04(%rip), %rax # 0x6ef938
leaq 0x50(%rsp), %r15
movq %rax, (%r15)
xorl %r13d, %r13d
movq %r13, 0x8(%r15)
movl $0x48, %edi
callq 0x1387d0
movl $0x1, %ecx
movl %ecx, (%rax)
leaq 0xa3f(%rip), %rcx # 0x50769a
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r12, 0x18(%rax)
movq 0x18(%rsp), %rdx
movq %rdx, 0x20(%rax)
movq 0x10(%rsp), %rdx
movq %rdx, 0x28(%rax)
movq %rbx, 0x30(%rax)
movq %r14, 0x38(%rax)
movq %rbp, 0x40(%rax)
movq %rcx, %r14
subq $0x8, %rsp
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq 0x10(%rsp), %rbp
movq %rbp, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
movq %rax, %r9
pushq 0x1e8e40(%rip) # 0x6efaf0
pushq %r13
pushq %r13
callq 0x143f40
addq $0x20, %rsp
movq %r12, %rdi
callq 0x13f960
movq 0x1e8bfc(%rip), %rbx # 0x6ef8c8
leaq 0x38(%rsp), %r12
movq %rbx, (%r12)
movq %r13, 0x8(%r12)
movq 0x1e7bf7(%rip), %rax # 0x6ee8d8
movq %rax, (%r15)
movq %r13, 0x8(%r15)
movl $0x20, %edi
callq 0x1387d0
movl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x155c(%rip), %rcx # 0x50825c
movq %rcx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r13, 0x18(%rax)
subq $0x8, %rsp
movq 0x1e8dc9(%rip), %r10 # 0x6efae0
leaq 0x30(%rsp), %r15
leaq 0x58(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rcx
movq %r12, %r8
movq %rax, %r9
pushq %r10
pushq %r13
pushq %r13
callq 0x143f40
addq $0x20, %rsp
movq %r15, %rdi
callq 0x13f960
movq 0x70(%rsp), %rax
testq %rax, %rax
je 0x506d6a
lock
decl (%rax)
jne 0x506d6a
movq 0x70(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x506d93
lock
decl (%rax)
jne 0x506d93
movq 0x90(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0xb0(%rsp), %rax
jne 0x506dbb
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/util/qundogroup.cpp |
QMetaTypeIdQObject<QUndoStack*, 8>::qt_metatype_id() | static int qt_metatype_id()
{
Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0);
if (const int id = metatype_id.loadAcquire())
return id;
const char *const cName = T::staticMetaObject.className();
QByteArray typeName;
typeName.reserve(strlen(cName) + 1);
typeName.append(cName).append('*');
const int newId = qRegisterNormalizedMetaType<T *>(typeName);
metatype_id.storeRelease(newId);
return newId;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movl 0x205919(%rip), %ebx # 0x70d208
testl %ebx, %ebx
je 0x507913
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x5079c7
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x1e7956(%rip), %rdi # 0x6ef270
callq 0x142490
movq %rax, %rbx
xorl %r14d, %r14d
movq %rsp, %r15
movq %r14, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq %rax, %rdi
callq 0x13c0e0
incq %rax
testq %rax, %rax
cmovgq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x144b20
movq (%r15), %rax
testq %rax, %rax
je 0x507968
cmpq $0x0, 0x8(%rax)
je 0x507968
orb $0x1, 0x4(%rax)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rdx
callq 0x166032
movq %rax, %rdi
movl $0x2a, %esi
callq 0x142e90
movq %r14, %rdi
callq 0x5079cc
movl %eax, %ebx
movl %eax, 0x20586e(%rip) # 0x70d208
movq (%r14), %rax
testq %rax, %rax
je 0x5078f3
lock
decl (%rax)
jne 0x5078f3
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x5078f3
callq 0x13a8c0
| /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QArrayDataPointer<QUndoStack*>::detachAndGrow(QArrayData::GrowthPosition, long long, QUndoStack* const**, QArrayDataPointer<QUndoStack*>*) | void detachAndGrow(QArrayData::GrowthPosition where, qsizetype n, const T **data,
QArrayDataPointer *old)
{
const bool detach = needsDetach();
bool readjusted = false;
if (!detach) {
if (!n || (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= 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 0x507e37
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x507e51
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x507a4a
testq %r14, %r14
je 0x507eb2
testl %ebp, %ebp
je 0x507e7e
cmpl $0x1, %ebp
jne 0x507e77
movq 0x8(%r15), %rdx
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jge 0x507eb2
movq %r15, %rdi
movl %ebp, %esi
jmp 0x507ea6
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 0x507eb2
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x507f16
testb %al, %al
je 0x507e37
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QUndoStack*>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QUndoStack* const**) | qsizetype constAllocatedCapacity() const noexcept { return d ? d->constAllocatedCapacity() : 0; } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x507f48
movq 0x8(%rax), %r9
movq 0x8(%rdi), %r8
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %r8
sarq $0x3, %r8
movq 0x10(%rdi), %rax
addq %r8, %rax
movq %r9, %r10
subq %rax, %r10
jmp 0x507f51
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %esi, %esi
jne 0x507f6d
cmpq %rdx, %r8
jl 0x507f6d
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rdx
addq %r9, %r9
xorl %eax, %eax
cmpq %r9, %rdx
jl 0x507fa5
retq
xorl %eax, %eax
cmpl $0x1, %esi
jne 0x507f6c
cmpq %rdx, %r10
jl 0x507f6c
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rsi
cmpq %r9, %rsi
jge 0x507fbb
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 0x507fbe
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
auto QtPrivate::sequential_erase_if<QList<QUndoStack*>, auto QtPrivate::sequential_erase<QList<QUndoStack*>, QUndoStack*>(QList<QUndoStack*>&, QUndoStack* const&)::'lambda'(QList<QUndoStack*> const&)>(QList<QUndoStack*>&, QUndoStack*&) | auto sequential_erase_if(Container &c, Predicate &pred)
{
// This is remove_if() modified to perform the find_if step on
// const_iterators to avoid shared container detaches if nothing needs to
// be removed. We cannot run remove_if after find_if: doing so would apply
// the predicate to the first matching element twice!
const auto cbegin = c.cbegin();
const auto cend = c.cend();
const auto t_it = std::find_if(cbegin, cend, pred);
auto result = std::distance(cbegin, t_it);
if (result == c.size())
return result - result; // `0` of the right type
// now detach:
const auto e = c.end();
auto it = std::next(c.begin(), result);
auto dest = it;
// Loop Invariants:
// - it != e
// - [next(it), e[ still to be checked
// - [c.begin(), dest[ are result
while (++it != e) {
if (!pred(*it)) {
*dest = std::move(*it);
++dest;
}
}
result = std::distance(dest, e);
c.erase(dest, e);
return result;
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rax
leaq (%r15,%rax,8), %rsi
movq (%r14), %rdx
movq %r15, %rdi
callq 0x50814f
movq %rax, %r12
subq %r15, %r12
movq %r12, %rax
sarq $0x3, %rax
cmpq 0x10(%rbx), %rax
jne 0x50808b
xorl %r14d, %r14d
jmp 0x5080db
movq %rbx, %rdi
callq 0x5077ca
movq %rax, %r15
movq %rbx, %rdi
callq 0x50779e
leaq (%rax,%r12), %rsi
addq %r12, %rax
addq $0x8, %rax
cmpq %r15, %rax
je 0x5080c6
movq (%rax), %rcx
movq (%r14), %rdx
cmpq (%rdx), %rcx
je 0x5080c0
movq %rcx, (%rsi)
addq $0x8, %rsi
addq $0x8, %rax
jmp 0x5080a9
movq %r15, %r14
subq %rsi, %r14
sarq $0x3, %r14
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5080ea
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QList<QUndoStack*>::erase(QList<QUndoStack*>::const_iterator, QList<QUndoStack*>::const_iterator) | typename QList<T>::iterator QList<T>::erase(const_iterator abegin, const_iterator aend)
{
Q_ASSERT_X(isValidIterator(abegin), "QList::erase", "The specified iterator argument 'abegin' is invalid");
Q_ASSERT_X(isValidIterator(aend), "QList::erase", "The specified iterator argument 'aend' is invalid");
Q_ASSERT(aend >= abegin);
qsizetype i = std::distance(constBegin(), abegin);
qsizetype n = std::distance(abegin, aend);
remove(i, n);
return begin() + i;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %r15
subq %rsi, %r15
subq %rax, %r14
je 0x50813e
sarq $0x3, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x50811e
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x508130
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x507a4a
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5081fe
movq %rbx, %rdi
callq 0x50779e
addq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QtPrivate::QPodArrayOps<QUndoStack*>::erase(QUndoStack**, long long) | void erase(T *b, qsizetype n)
{
T *e = b + n;
Q_ASSERT(this->isMutable());
Q_ASSERT(b < e);
Q_ASSERT(b >= this->begin() && b < this->end());
Q_ASSERT(e > this->begin() && e <= this->end());
// Comply with std::vector::erase(): erased elements and all after them
// 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,8), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
cmpq %rax, %rdx
setne %dil
leaq (%rdx,%rcx,8), %rdx
cmpq %rdx, %rsi
sete %r8b
orb %dil, %r8b
je 0x508248
cmpq %rdx, %rsi
je 0x50824c
subq %rsi, %rdx
movq %rax, %rdi
callq 0x138810
movq 0x10(%r14), %rcx
jmp 0x50824c
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 |
qglx_buildSpec(QSurfaceFormat const&, int, int) | QList<int> qglx_buildSpec(const QSurfaceFormat &format, int drawableBit, int flags)
{
QList<int> spec;
spec << GLX_LEVEL
<< 0
<< GLX_RENDER_TYPE
<< GLX_RGBA_BIT
<< GLX_RED_SIZE
<< qMax(1, format.redBufferSize())
<< GLX_GREEN_SIZE
<< qMax(1, format.greenBufferSize())
<< GLX_BLUE_SIZE
<< qMax(1, format.blueBufferSize())
<< GLX_ALPHA_SIZE
<< qMax(0, format.alphaBufferSize());
if (format.swapBehavior() != QSurfaceFormat::SingleBuffer)
spec << GLX_DOUBLEBUFFER
<< True;
if (format.stereo())
spec << GLX_STEREO
<< True;
if (format.depthBufferSize() != -1)
spec << GLX_DEPTH_SIZE
<< format.depthBufferSize();
if (format.stencilBufferSize() != -1)
spec << GLX_STENCIL_SIZE
<< format.stencilBufferSize();
if (format.samples() > 1)
spec << GLX_SAMPLE_BUFFERS_ARB
<< 1
<< GLX_SAMPLES_ARB
<< format.samples();
if ((flags & QGLX_SUPPORTS_SRGB) && format.colorSpace() == QColorSpace::SRgb)
spec << GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB
<< True;
spec << GLX_DRAWABLE_TYPE
<< drawableBit
<< XNone;
return spec;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r12
movl $0x3, (%r12)
xorl %r13d, %r13d
xorl %esi, %esi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl %r13d, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x8011, (%r12) # imm = 0x8011
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x1, %ebp
movl %ebp, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x8, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x1413c0
cmpl $0x2, %eax
cmovll %ebp, %eax
movl %eax, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x9, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x13df70
cmpl $0x2, %eax
cmovll %ebp, %eax
movl %eax, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0xa, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x1437f0
cmpl $0x2, %eax
cmovgel %eax, %ebp
movl %ebp, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0xb, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x143f90
testl %eax, %eax
cmovgl %eax, %r13d
movl %r13d, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x142780
cmpl $0x1, %eax
je 0x50851d
leaq 0x8(%rsp), %r12
movl $0x5, (%r12)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x1, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
movl $0x1, %esi
callq 0x140b90
testb %al, %al
je 0x508573
leaq 0x8(%rsp), %r12
movl $0x6, (%r12)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x1, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x143d40
cmpl $-0x1, %eax
je 0x5085c9
leaq 0x8(%rsp), %r12
movl $0xc, (%r12)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x143d40
movl %eax, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x138d80
cmpl $-0x1, %eax
je 0x50861f
leaq 0x8(%rsp), %r12
movl $0xd, (%r12)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x138d80
movl %eax, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x146a20
cmpl $0x2, %eax
jl 0x5086c1
leaq 0x8(%rsp), %r12
movl $0x186a0, (%r12) # imm = 0x186A0
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x1, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x186a1, (%r12) # imm = 0x186A1
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %r14, %rdi
callq 0x146a20
movl %eax, (%r12)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
testb $0x1, %r15b
je 0x508742
movq %r14, %rdi
callq 0x143100
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
callq 0x140270
movq %r14, %rdi
movq %r15, %rsi
callq 0x1431b0
movl %eax, %r14d
movq %r15, %rdi
callq 0x137710
testb %r14b, %r14b
je 0x508742
leaq 0x8(%rsp), %r14
movl $0x20b2, (%r14) # imm = 0x20B2
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x1, (%r14)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
leaq 0x8(%rsp), %r14
movl $0x8010, (%r14) # imm = 0x8010
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl 0x4(%rsp), %eax
movl %eax, (%r14)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movl $0x0, (%r14)
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x5087ca
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/opengl/platform/unix/qglxconvenience.cpp |
qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat*, _XDisplay*, __GLXFBConfigRec*, int) | void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, GLXFBConfig config, int flags)
{
int redSize = 0;
int greenSize = 0;
int blueSize = 0;
int alphaSize = 0;
int depthSize = 0;
int stencilSize = 0;
int sampleBuffers = 0;
int sampleCount = 0;
int stereo = 0;
int srgbCapable = 0;
glXGetFBConfigAttrib(display, config, GLX_RED_SIZE, &redSize);
glXGetFBConfigAttrib(display, config, GLX_GREEN_SIZE, &greenSize);
glXGetFBConfigAttrib(display, config, GLX_BLUE_SIZE, &blueSize);
glXGetFBConfigAttrib(display, config, GLX_ALPHA_SIZE, &alphaSize);
glXGetFBConfigAttrib(display, config, GLX_DEPTH_SIZE, &depthSize);
glXGetFBConfigAttrib(display, config, GLX_STENCIL_SIZE, &stencilSize);
glXGetFBConfigAttrib(display, config, GLX_SAMPLE_BUFFERS_ARB, &sampleBuffers);
glXGetFBConfigAttrib(display, config, GLX_STEREO, &stereo);
if (flags & QGLX_SUPPORTS_SRGB)
glXGetFBConfigAttrib(display, config, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &srgbCapable);
format->setRedBufferSize(redSize);
format->setGreenBufferSize(greenSize);
format->setBlueBufferSize(blueSize);
format->setAlphaBufferSize(alphaSize);
format->setDepthBufferSize(depthSize);
format->setStencilBufferSize(stencilSize);
if (sampleBuffers) {
glXGetFBConfigAttrib(display, config, GLX_SAMPLES_ARB, &sampleCount);
format->setSamples(sampleCount);
}
if (srgbCapable)
format->setColorSpace(QColorSpace::SRgb);
else
format->setColorSpace(QColorSpace());
format->setStereo(stereo);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
xorl %eax, %eax
leaq 0x3c(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x38(%rsp), %rbp
movl %eax, (%rbp)
leaq 0x34(%rsp), %r12
movl %eax, (%r12)
leaq 0x30(%rsp), %r13
movl %eax, (%r13)
leaq 0x2c(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x28(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x24(%rsp), %rdx
movl %eax, (%rdx)
movl %eax, 0x20(%rsp)
leaq 0x1c(%rsp), %rdx
movl %eax, (%rdx)
movl %eax, 0x18(%rsp)
movq %rsi, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x141d50
movq %r15, %rdi
movq %r14, %rsi
movl $0x9, %edx
movq %rbp, %rcx
callq 0x141d50
movq %r15, %rdi
movq %r14, %rsi
movl $0xa, %edx
movq %r12, %rcx
callq 0x141d50
movq %r15, %rdi
movq %r14, %rsi
movl $0xb, %edx
movq %r13, %rcx
callq 0x141d50
movq %r15, %rdi
movq %r14, %rsi
movl $0xc, %edx
leaq 0x2c(%rsp), %rcx
callq 0x141d50
movq %r15, %rdi
movq %r14, %rsi
movl $0xd, %edx
leaq 0x28(%rsp), %rcx
callq 0x141d50
movq %r15, %rdi
movq %r14, %rsi
movl $0x186a0, %edx # imm = 0x186A0
leaq 0x24(%rsp), %rcx
callq 0x141d50
movq %r15, %rdi
movq %r14, %rsi
movl $0x6, %edx
leaq 0x1c(%rsp), %rcx
callq 0x141d50
testb $0x1, 0xc(%rsp)
je 0x5093e2
leaq 0x18(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl $0x20b2, %edx # imm = 0x20B2
callq 0x141d50
movl 0x3c(%rsp), %esi
movq %rbx, %rdi
callq 0x13d170
movl 0x38(%rsp), %esi
movq %rbx, %rdi
callq 0x137880
movl 0x34(%rsp), %esi
movq %rbx, %rdi
callq 0x13c250
movl 0x30(%rsp), %esi
movq %rbx, %rdi
callq 0x142fb0
movl 0x2c(%rsp), %esi
movq %rbx, %rdi
callq 0x1428d0
movl 0x28(%rsp), %esi
movq %rbx, %rdi
callq 0x138230
cmpl $0x0, 0x24(%rsp)
je 0x509455
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movl $0x186a1, %edx # imm = 0x186A1
movq %r12, %rcx
callq 0x141d50
movl (%r12), %esi
movq %rbx, %rdi
callq 0x13da60
cmpl $0x0, 0x18(%rsp)
je 0x509470
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0x140270
jmp 0x50947c
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x141720
movq %r14, %rdi
callq 0x137710
xorl %esi, %esi
cmpl $0x0, 0x1c(%rsp)
setne %sil
movq %rbx, %rdi
callq 0x142030
movq %fs:0x28, %rax
cmpq 0x40(%rsp), %rax
jne 0x5094c1
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/opengl/platform/unix/qglxconvenience.cpp |
QEGLPlatformContext::QEGLPlatformContext(QSurfaceFormat const&, QPlatformOpenGLContext*, void*, void**, QFlags<QEGLPlatformContext::Flag>) | QEGLPlatformContext::QEGLPlatformContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share, EGLDisplay display,
EGLConfig *config, Flags flags)
: m_eglDisplay(display)
, m_flags(flags)
, m_ownsContext(true)
{
m_eglConfig = config ? *config : q_configFromGLFormat(display, format);
m_format = q_glFormatFromConfig(m_eglDisplay, m_eglConfig, format);
// m_format now has the renderableType() resolved (it cannot be Default anymore)
// but does not yet contain version, profile, options.
m_shareContext = share ? static_cast<QEGLPlatformContext *>(share)->m_eglContext : nullptr;
QList<EGLint> contextAttrs;
contextAttrs.append(EGL_CONTEXT_CLIENT_VERSION);
contextAttrs.append(format.majorVersion());
const bool hasKHRCreateContext = q_hasEglExtension(m_eglDisplay, "EGL_KHR_create_context");
if (hasKHRCreateContext) {
contextAttrs.append(EGL_CONTEXT_MINOR_VERSION_KHR);
contextAttrs.append(format.minorVersion());
int flags = 0;
// The debug bit is supported both for OpenGL and OpenGL ES.
if (format.testOption(QSurfaceFormat::DebugContext))
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
// The fwdcompat bit is only for OpenGL 3.0+.
if (m_format.renderableType() == QSurfaceFormat::OpenGL
&& format.majorVersion() >= 3
&& !format.testOption(QSurfaceFormat::DeprecatedFunctions))
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
if (flags) {
contextAttrs.append(EGL_CONTEXT_FLAGS_KHR);
contextAttrs.append(flags);
}
// Profiles are OpenGL only and mandatory in 3.2+. The value is silently ignored for < 3.2.
if (m_format.renderableType() == QSurfaceFormat::OpenGL) {
contextAttrs.append(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR);
contextAttrs.append(format.profile() == QSurfaceFormat::CoreProfile
? EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
: EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR);
}
}
#ifdef EGL_EXT_protected_content
if (format.testOption(QSurfaceFormat::ProtectedContent)) {
if (q_hasEglExtension(m_eglDisplay, "EGL_EXT_protected_content")) {
contextAttrs.append(EGL_PROTECTED_CONTENT_EXT);
contextAttrs.append(EGL_TRUE);
} else {
m_format.setOption(QSurfaceFormat::ProtectedContent, false);
}
}
#endif
// Special Options for OpenVG surfaces
if (m_format.renderableType() == QSurfaceFormat::OpenVG) {
contextAttrs.append(EGL_ALPHA_MASK_SIZE);
contextAttrs.append(8);
}
contextAttrs.append(EGL_NONE);
m_contextAttrs = contextAttrs;
switch (m_format.renderableType()) {
case QSurfaceFormat::OpenVG:
m_api = EGL_OPENVG_API;
break;
#ifdef EGL_VERSION_1_4
case QSurfaceFormat::OpenGL:
m_api = EGL_OPENGL_API;
break;
#endif // EGL_VERSION_1_4
default:
m_api = EGL_OPENGL_ES_API;
break;
}
eglBindAPI(m_api);
m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, m_shareContext, contextAttrs.constData());
if (m_eglContext == EGL_NO_CONTEXT && m_shareContext != EGL_NO_CONTEXT) {
m_shareContext = nullptr;
m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, nullptr, contextAttrs.constData());
}
if (m_eglContext == EGL_NO_CONTEXT) {
qWarning("QEGLPlatformContext: Failed to create context: %x", eglGetError());
return;
}
static const bool printConfig = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DEBUG");
if (printConfig) {
qDebug() << "Created context for format" << format << "with config:";
q_printEglConfig(m_eglDisplay, m_eglConfig);
static const bool printAllConfigs = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DEBUG") > 1;
if (printAllConfigs) {
EGLint numConfigs = 0;
eglGetConfigs(m_eglDisplay, nullptr, 0, &numConfigs);
QVector<EGLConfig> configs;
configs.resize(numConfigs);
eglGetConfigs(m_eglDisplay, configs.data(), numConfigs, &numConfigs);
qDebug("\nAll EGLConfigs: count=%d", numConfigs);
for (EGLint i = 0; i < numConfigs; ++i) {
qDebug("EGLConfig #%d", i);
q_printEglConfig(m_eglDisplay, configs[i]);
}
qDebug("\n");
}
}
// Cannot just call updateFormatFromGL() since it relies on virtuals. Defer it to initialize().
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %r14d
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x80(%rsp)
callq 0x144dc0
movq 0x1e631c(%rip), %rax # 0x6efc20
leaq 0x10(%rax), %rcx
movq %rcx, (%rbx)
addq $0xc8, %rax
movq %rax, 0x10(%rbx)
movq %r13, 0x28(%rbx)
leaq 0x38(%rbx), %rdi
movq %rdi, (%rsp)
callq 0x13e210
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, 0x44(%rbx)
movb $0x0, 0x48(%rbx)
movl %eax, 0x4c(%rbx)
movl %r14d, 0x50(%rbx)
movb $0x1, 0x54(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x61(%rbx)
testq %rbp, %rbp
je 0x509953
movq (%rbp), %rdx
jmp 0x509968
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl $0x4, %ecx
callq 0x148170
movq %rax, %rdx
movq %r15, %rbp
movq %rdx, 0x30(%rbx)
movq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
callq 0x146ee0
movq (%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x139390
movq %r14, %rdi
callq 0x143510
testq %r12, %r12
je 0x5099a6
movq 0x18(%r12), %rax
jmp 0x5099a8
xorl %eax, %eax
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
leaq 0x8(%rsp), %r14
movl $0x3098, (%r14) # imm = 0x3098
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
movq %rbp, %rdi
callq 0x138460
movl %eax, (%r14)
movq 0x10(%r12), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
movq 0x28(%rbx), %rdi
leaq 0xadd2d(%rip), %rsi # 0x5b7740
callq 0x145770
testb %al, %al
je 0x509b88
leaq 0x8(%rsp), %r14
movl $0x30fb, (%r14) # imm = 0x30FB
leaq 0x40(%rsp), %r12
movq 0x10(%r12), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
movq %rbp, %rdi
callq 0x13d390
movl %eax, (%r14)
movq 0x10(%r12), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
movq %rbp, %rdi
movl $0x2, %esi
callq 0x140b90
movzbl %al, %r14d
movq %r15, %rdi
callq 0x138a30
cmpl $0x1, %eax
jne 0x509ac6
movq %rbp, %rdi
callq 0x138460
cmpl $0x3, %eax
jl 0x509ac6
movq %rbp, %r15
movq %rbp, %rdi
movl $0x4, %esi
callq 0x140b90
leal 0x2(%r14), %ecx
movl %eax, %edx
xorb $0x1, %dl
orb %dl, %r14b
testb %al, %al
movl $0x1, %ebp
cmovel %ecx, %ebp
testb %r14b, %r14b
jne 0x509ad3
jmp 0x509b19
movq %rbp, %r15
movl $0x1, %ebp
testl %r14d, %r14d
je 0x509b19
leaq 0x8(%rsp), %r14
movl $0x30fc, (%r14) # imm = 0x30FC
leaq 0x40(%rsp), %r12
movq 0x10(%r12), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
movl %ebp, (%r14)
movq 0x10(%r12), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
movq (%rsp), %r14
movq %r14, %rdi
callq 0x138a30
cmpl $0x1, %eax
movq %r15, %rbp
movq %r14, %r15
jne 0x509b88
leaq 0x8(%rsp), %r14
movl $0x30fd, (%r14) # imm = 0x30FD
leaq 0x40(%rsp), %r12
movq 0x10(%r12), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
movq %rbp, %rdi
callq 0x13e890
xorl %ecx, %ecx
cmpl $0x1, %eax
setne %cl
incl %ecx
movl %ecx, (%r14)
movq 0x10(%r12), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
movq %rbp, %rdi
movl $0x10, %esi
callq 0x140b90
testb %al, %al
je 0x509c08
movq 0x28(%rbx), %rdi
leaq 0xbca6c(%rip), %rsi # 0x5c6610
callq 0x145770
testb %al, %al
je 0x509bf9
leaq 0x8(%rsp), %r14
movl $0x32c0, (%r14) # imm = 0x32C0
leaq 0x40(%rsp), %r12
movq 0x10(%r12), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
movl $0x1, (%r14)
movq 0x10(%r12), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x1a1b70
movq %r12, %rdi
callq 0x1a18ba
jmp 0x509c08
movq %r15, %rdi
movl $0x10, %esi
xorl %edx, %edx
callq 0x148990
leaq 0x58(%rbx), %r12
movq %r15, %rdi
callq 0x138a30
cmpl $0x4, %eax
jne 0x509c61
leaq 0x8(%rsp), %r14
movl $0x303e, (%r14) # imm = 0x303E
leaq 0x40(%rsp), %r13
movq 0x10(%r13), %rsi
movq %r13, %rdi
movq %r14, %rdx
callq 0x1a1b70
movq %r13, %rdi
callq 0x1a18ba
movl $0x8, (%r14)
movq 0x10(%r13), %rsi
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
callq 0x1a1b70
movq %r13, %rdi
callq 0x1a18ba
leaq 0x8(%rsp), %rdx
movl $0x3038, (%rdx) # imm = 0x3038
leaq 0x40(%rsp), %r13
movq 0x10(%r13), %rsi
movq %r13, %rdi
callq 0x1a1b70
movq %r13, %rdi
callq 0x1a18ba
movq %r12, %rdi
movq %r13, %rsi
callq 0x50a9bc
movq %r15, %rdi
callq 0x138a30
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
leal 0x30a0(,%rcx,2), %ecx
cmpl $0x4, %eax
movl $0x30a1, %edi # imm = 0x30A1
cmovnel %ecx, %edi
movl %edi, 0x40(%rbx)
callq 0x146900
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x8(%r13), %rcx
callq 0x1375f0
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x509cff
cmpq $0x0, 0x20(%rbx)
je 0x509cff
movq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x48(%rsp), %rcx
xorl %edx, %edx
callq 0x1375f0
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x509fb8
movb 0x203532(%rip), %al # 0x70d240
testb %al, %al
je 0x50a00a
cmpb $0x1, 0x20351b(%rip) # 0x70d238
jne 0x509fbd
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
leaq 0x972eb(%rip), %r12 # 0x5a102e
movq %r12, 0x18(%rsi)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x13ecf0
movq (%r14), %r14
leaq 0xbc911(%rip), %rdx # 0x5c666f
leaq 0x60(%rsp), %r15
movl $0x1a, %esi
movq %r15, %rdi
callq 0x1457d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x509d9c
lock
decl (%rax)
jne 0x509d9c
movq 0x60(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x28(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x509db6
movl $0x20, %esi
callq 0x13d680
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rdi, (%rsi)
incl 0x28(%rdi)
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rdx
callq 0x13d030
movq (%r14), %r14
leaq 0xbc8af(%rip), %rdx # 0x5c668a
leaq 0x60(%rsp), %r15
movl $0xc, %esi
movq %r15, %rdi
callq 0x1457d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x509e19
lock
decl (%rax)
jne 0x509e19
movq 0x60(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x38(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x509e2e
movl $0x20, %esi
callq 0x13d680
leaq 0x38(%rsp), %rdi
callq 0x1391b0
leaq 0x30(%rsp), %rdi
callq 0x1391b0
leaq 0x28(%rsp), %rdi
callq 0x1391b0
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x142d20
movb 0x2033f1(%rip), %al # 0x70d250
testb %al, %al
je 0x50a014
cmpb $0x1, 0x2033da(%rip) # 0x70d248
jne 0x509fbd
xorl %r13d, %r13d
leaq 0x38(%rsp), %r14
movl %r13d, (%r14)
movq 0x28(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x140a50
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movslq (%r14), %rsi
movq %r15, %rdi
callq 0x50a8a0
movq %r12, %rbp
movq 0x28(%rbx), %r12
movq %r15, %rdi
callq 0x47f04a
movl (%r14), %edx
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x140a50
leaq 0x8(%rsp), %rdi
movl $0x2, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movl %r13d, 0x14(%rdi)
movq %rbp, 0x18(%rdi)
movl (%r14), %edx
leaq 0xbc7a5(%rip), %rsi # 0x5c6697
xorl %eax, %eax
callq 0x13c920
cmpl %r13d, (%r14)
jle 0x509f68
leaq 0xc(%rsp), %r14
leaq 0x60(%rsp), %r12
xorl %r13d, %r13d
movl $0x2, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movq %rbp, 0x20(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0xbc77e(%rip), %rsi # 0x5c66b1
movl %r13d, %edx
xorl %eax, %eax
callq 0x13c920
movq %rbp, %r15
movq 0x28(%rbx), %rbp
movq %r12, %rdi
callq 0x47f04a
movq (%rax,%r13,8), %rsi
movq %rbp, %rdi
movq %r15, %rbp
callq 0x142d20
incq %r13
movslq 0x38(%rsp), %rax
cmpq %rax, %r13
jl 0x509f0b
leaq 0x8(%rsp), %rdi
movl $0x2, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rbp, 0x18(%rdi)
leaq 0x6e1e4(%rip), %rsi # 0x578170
xorl %eax, %eax
callq 0x13c920
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x509fbd
lock
decl (%rax)
jne 0x509fbd
movq 0x60(%rsp), %rdi
movl $0x8, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x509fbd
callq 0x162422
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x509fe0
lock
decl (%rax)
jne 0x509fe0
movq 0x40(%rsp), %rdi
movl $0x4, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x80(%rsp), %rax
jne 0x50a005
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
callq 0x1623b5
jmp 0x509d16
callq 0x1623eb
jmp 0x509e67
| /qt[P]qtbase/src/gui/opengl/platform/egl/qeglplatformcontext.cpp |
QMap<QString, QVariant>::value(QString const&, QVariant const&) const | T value(const Key &key, const T &defaultValue = T()) const
{
if (!d)
return defaultValue;
const auto i = d->m.find(key);
if (i != d->m.cend())
return i->second;
return defaultValue;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x525332
movq %rsi, %r15
addq $0x8, %rdi
movq %rdx, %rsi
callq 0x525346
movq (%r15), %rcx
addq $0x10, %rcx
leaq 0x38(%rax), %rdx
cmpq %rcx, %rax
cmovneq %rdx, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13d0f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /qt[P]qtbase/src/corelib/tools/qmap.h |
QtPrivate::QMetaTypeForType<QDBusObjectPath>::getDtor()::'lambda'(QtPrivate::QMetaTypeInterface const*, void*)::__invoke(QtPrivate::QMetaTypeInterface const*, void*) | bool deref() noexcept { return !d || d->deref(); } | endbr64
movq (%rsi), %rax
testq %rax, %rax
je 0x525629
lock
decl (%rax)
jne 0x525629
movq (%rsi), %rdi
movl $0x2, %esi
movl $0x10, %edx
jmp 0x143f00
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QLessThanOperatorForType<QDBusObjectPath, true>::lessThan(QtPrivate::QMetaTypeInterface const*, void const*, void const*) | static bool lessThan(const QMetaTypeInterface *, const void *a, const void *b)
{ return *reinterpret_cast<const T *>(a) < *reinterpret_cast<const T *>(b); } | endbr64
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
movq (%rsi), %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %rdi
testq %rbx, %rbx
je 0x5256ce
lock
incl (%rbx)
movq (%rdx), %r14
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %rdx
testq %r14, %r14
je 0x525709
lock
incl (%r14)
movl $0x1, %r8d
callq 0x13a6c0
movl %eax, %ebp
lock
decl (%r14)
jne 0x525716
movl $0x2, %esi
movl $0x10, %edx
movq %r14, %rdi
callq 0x143f00
jmp 0x525716
movl $0x1, %r8d
callq 0x13a6c0
movl %eax, %ebp
testq %rbx, %rbx
je 0x525732
lock
decl (%rbx)
jne 0x525732
movl $0x2, %esi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x143f00
shrl $0x1f, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QDBusObjectPath qdbus_cast<QDBusObjectPath>(QVariant const&) | inline T qdbus_cast(const QVariant &v)
{
if (v.metaType() == QMetaType::fromType<QDBusArgument>())
return qdbus_cast<T>(qvariant_cast<QDBusArgument>(v));
else
return qvariant_cast<T>(v);
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movq %rsi, %rdi
callq 0x139130
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1d3089(%rip), %r15 # 0x6f89d0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
callq 0x16a00a
testb %al, %al
je 0x5259a0
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
movq 0x18(%r14), %rax
andq $-0x4, %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x16a00a
testb %al, %al
je 0x525a04
testb $0x1, 0x18(%r14)
je 0x52598e
movq (%r14), %rax
movslq 0x4(%rax), %r14
addq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x13ab40
jmp 0x525a49
leaq 0x1d3109(%rip), %rax # 0x6f8ab0
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x18(%r14), %rax
andq $-0x4, %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x16a00a
testb %al, %al
je 0x525a71
testb $0x1, 0x18(%r14)
je 0x5259dd
movq (%r14), %rax
movslq 0x4(%rax), %r14
addq %rax, %r14
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
testq %rax, %rax
je 0x525aab
lock
incl (%rax)
jmp 0x525aab
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x13c560
movq %r14, %rdi
callq 0x139130
testb $0x1, 0x18(%r14)
je 0x525a34
movq (%r14), %rcx
movslq 0x4(%rcx), %r14
addq %rcx, %r14
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1376b0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x141ef0
movq %r14, %rdi
callq 0x139830
jmp 0x525aab
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x139130
testb $0x1, 0x18(%r14)
je 0x525a98
movq (%r14), %rcx
movslq 0x4(%rcx), %r14
addq %rcx, %r14
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x1376b0
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x525ac8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/dbus/qdbusargument.h |
QtPrivate::QExplicitlySharedDataPointerV2<QMapData<std::map<QString, QVariant, std::less<QString>, std::allocator<std::pair<QString const, QVariant>>>>>::reset(QMapData<std::map<QString, QVariant, std::less<QString>, std::allocator<std::pair<QString const, QVariant>>>>*) | void reset(T *t = nullptr) noexcept
{
if (d && !d->ref.deref())
delete d.get();
d.reset(t);
if (d)
d->ref.ref();
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x525d6a
lock
decl (%rax)
jne 0x525d6a
movq (%r14), %r15
testq %r15, %r15
je 0x525d5d
leaq 0x8(%r15), %rdi
movq 0x18(%r15), %rsi
callq 0x525f8e
movl $0x38, %esi
movq %r15, %rdi
callq 0x137fb0
movq %rbx, (%r14)
testq %rbx, %rbx
je 0x525d75
lock
incl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
| /qt[P]qtbase/src/corelib/tools/qshareddata_impl.h |
void QtPrivate::QMovableArrayOps<QDBusUnixFileDescriptor>::emplace<QDBusUnixFileDescriptor const&>(long long, QDBusUnixFileDescriptor const&) | void emplace(qsizetype i, Args &&... args)
{
bool detach = this->needsDetach();
if (!detach) {
if (i == this->size && this->freeSpaceAtEnd()) {
new (this->end()) T(std::forward<Args>(args)...);
++this->size;
return;
}
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)...);
const bool growsAtBegin = this->size != 0 && i == 0;
const auto pos = growsAtBegin ? Data::GrowsAtBeginning : Data::GrowsAtEnd;
this->detachAndGrow(pos, 1, nullptr, nullptr);
if (growsAtBegin) {
Q_ASSERT(this->freeSpaceAtBegin());
new (this->begin() - 1) T(std::move(tmp));
--this->ptr;
++this->size;
} else {
Inserter(this, i, 1).insertOne(std::move(tmp));
}
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movq (%rdi), %rax
testq %rax, %rax
je 0x52643a
movl (%rax), %ecx
cmpl $0x1, %ecx
jg 0x52643a
cmpq %r14, 0x10(%rbx)
jne 0x526420
movq 0x8(%rbx), %rcx
leaq 0x1f(%rax), %rsi
andq $-0x10, %rsi
movq %rcx, %rdi
subq %rsi, %rdi
sarq $0x3, %rdi
addq %r14, %rdi
cmpq %rdi, 0x8(%rax)
jne 0x52651c
testq %r14, %r14
jne 0x52643a
movq 0x8(%rbx), %rdi
addq $0x1f, %rax
andq $-0x10, %rax
cmpq %rdi, %rax
jne 0x52652a
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, %rsi
callq 0x13b480
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 0x52657a
cmpb $0x1, %bpl
jne 0x52649e
movq 0x8(%rbx), %rdi
addq $-0x8, %rdi
leaq 0x28(%rsp), %rsi
callq 0x13b480
addq $-0x8, 0x8(%rbx)
incq 0x10(%rbx)
jmp 0x5264f3
movq %rsp, %r15
movq %rbx, (%r15)
movq 0x8(%rbx), %rax
leaq (%rax,%r14,8), %r12
leaq (%rax,%r14,8), %r13
addq $0x8, %r13
movq %r13, 0x10(%r15)
movq $0x1, 0x18(%r15)
movq 0x10(%rbx), %rdx
subq %r14, %rdx
shlq $0x3, %rdx
movq %rdx, 0x20(%r15)
movq %r13, %rdi
movq %r12, %rsi
callq 0x138810
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x13b480
movq %r13, 0x8(%r15)
movq %r15, %rdi
callq 0x526626
leaq 0x28(%rsp), %rdi
callq 0x143db0
movq %fs:0x28, %rax
cmpq 0x30(%rsp), %rax
jne 0x526541
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%rcx,%r14,8), %rdi
movq %rdx, %rsi
callq 0x13b480
jmp 0x52653b
addq $-0x8, %rdi
movq %rdx, %rsi
callq 0x13b480
addq $-0x8, 0x8(%rbx)
incq 0x10(%rbx)
jmp 0x5264fd
callq 0x13a8c0
| /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
int qRegisterNormalizedMetaTypeImplementation<QList<QDBusUnixFileDescriptor>>(QByteArray const&) | int qRegisterNormalizedMetaTypeImplementation(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName)
{
#ifndef QT_NO_QOBJECT
Q_ASSERT_X(normalizedTypeName == QMetaObject::normalizedType(normalizedTypeName.constData()),
"qRegisterNormalizedMetaType",
"qRegisterNormalizedMetaType was called with a not normalized type name, "
"please call qRegisterMetaType instead.");
#endif
const QMetaType metaType = QMetaType::fromType<T>();
const int id = metaType.id();
QtPrivate::SequentialContainerTransformationHelper<T>::registerConverter();
QtPrivate::SequentialContainerTransformationHelper<T>::registerMutableView();
QtPrivate::AssociativeContainerTransformationHelper<T>::registerConverter();
QtPrivate::AssociativeContainerTransformationHelper<T>::registerMutableView();
QtPrivate::MetaTypePairHelper<T>::registerConverter();
QtPrivate::MetaTypeSmartPointerHelper<T>::registerConverter();
#if QT_CONFIG(future)
QtPrivate::MetaTypeQFutureHelper<T>::registerConverter();
#endif
if (normalizedTypeName != metaType.name())
QMetaType::registerNormalizedTypedef(normalizedTypeName, metaType);
return id;
} | endbr64
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movl 0x1d1c74(%rip), %ebx # 0x6f8b2c
testl %ebx, %ebx
jne 0x526eca
leaq 0x1d1c5d(%rip), %rdi # 0x6f8b20
callq 0x139f90
movl %eax, %ebx
leaq 0x1d1c4f(%rip), %rdi # 0x6f8b20
callq 0x146e70
testb %al, %al
jne 0x526edf
callq 0x526f3e
leaq 0x1d1c3a(%rip), %rdi # 0x6f8b20
callq 0x139b40
testb %al, %al
jne 0x526ef4
callq 0x5276d0
movq 0x1d1c3d(%rip), %rax # 0x6f8b38
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x1660ec
testb %al, %al
je 0x526f1e
leaq 0x1d1c0a(%rip), %rsi # 0x6f8b20
movq %r14, %rdi
callq 0x146700
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x526f38
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QList<QDBusUnixFileDescriptor>::clear() | void clear() {
if (!size())
return;
if (d->needsDetach()) {
// must allocate memory
DataPointer detached(d.allocatedCapacity());
d.swap(detached);
} else {
d->truncate(0);
}
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x5273b2
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x527324
movl (%rax), %ecx
cmpl $0x2, %ecx
jl 0x527390
movaps 0x4d367(%rip), %xmm0 # 0x574680
movups %xmm0, 0x10(%rsp)
movq 0x8(%rax), %rcx
jmp 0x527332
movaps 0x4d355(%rip), %xmm0 # 0x574680
movups %xmm0, 0x10(%rsp)
xorl %ecx, %ecx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
movl $0x8, %esi
movl $0x10, %edx
movq %r14, %rdi
movl $0x1, %r8d
callq 0x138b60
movq (%r14), %rcx
movq (%rbx), %rdx
movq %rcx, (%rbx)
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, 0x8(%rdi)
movq 0x10(%rbx), %rax
movq $0x0, 0x10(%rbx)
movq %rax, 0x10(%rdi)
callq 0x526ae8
jmp 0x5273b2
movq 0x8(%rbx), %r14
shlq $0x3, %r15
movq %r14, %rdi
callq 0x143db0
addq $0x8, %r14
addq $-0x8, %r15
jne 0x527398
movq $0x0, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x28(%rsp), %rax
jne 0x5273cc
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QDBusUnixFileDescriptor>::pop_back() | void pop_back() noexcept { removeLast(); } | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x52747b
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x527489
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x52671c
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq (%rax,%rcx,8), %rdi
addq $-0x8, %rdi
callq 0x143db0
decq 0x10(%rbx)
popq %rbx
retq
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QDBusUnixFileDescriptor>::erase(QList<QDBusUnixFileDescriptor>::const_iterator, QList<QDBusUnixFileDescriptor>::const_iterator) | typename QList<T>::iterator QList<T>::erase(const_iterator abegin, const_iterator aend)
{
Q_ASSERT_X(isValidIterator(abegin), "QList::erase", "The specified iterator argument 'abegin' is invalid");
Q_ASSERT_X(isValidIterator(aend), "QList::erase", "The specified iterator argument 'aend' is invalid");
Q_ASSERT(aend >= abegin);
qsizetype i = std::distance(constBegin(), abegin);
qsizetype n = std::distance(abegin, aend);
remove(i, n);
return begin() + i;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %r15
subq %rsi, %r15
subq %rax, %r14
je 0x52762e
sarq $0x3, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x52760e
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x527620
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x52671c
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x527640
movq %rbx, %rdi
callq 0x5273d2
addq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
bool QMetaType::registerMutableView<QList<QDBusUnixFileDescriptor>, QIterable<QMetaSequence>, QtPrivate::QSequentialIterableMutableViewFunctor<QList<QDBusUnixFileDescriptor>>>(QtPrivate::QSequentialIterableMutableViewFunctor<QList<QDBusUnixFileDescriptor>>) | static bool registerMutableView(UnaryFunction function)
{
static_assert((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn),
"QMetaType::registerMutableView: At least one of the types must be a custom type.");
const QMetaType fromType = QMetaType::fromType<From>();
const QMetaType toType = QMetaType::fromType<To>();
auto view = [function = std::move(function)](void *from, void *to) -> bool {
From *f = static_cast<From *>(from);
To *t = static_cast<To *>(to);
*t = function(*f);
return true;
};
return registerMutableViewImpl<From, To>(std::move(view), fromType, toType);
} | endbr64
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movb $-0x56, (%r14)
leaq 0xb0(%rip), %rax # 0x5277ae
movq %rax, 0x18(%r14)
leaq 0xcb(%rip), %rax # 0x5277d4
movq %rax, 0x10(%r14)
leaq 0x1d140c(%rip), %rsi # 0x6f8b20
leaq 0x1c8cdd(%rip), %rdx # 0x6f03f8
movq %r14, %rdi
callq 0x52775a
movl %eax, %ebx
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x52773b
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x527755
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
| /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QString QStringBuilder<QStringBuilder<QString, QString>, QString>::convertTo<QString>() const | T convertTo() const
{
if (isNull()) {
// appending two null strings must give back a null string,
// so we're special casing this one out, QTBUG-114206
return T();
}
const qsizetype len = Concatenable::size(*this);
T s(len, Qt::Uninitialized);
// Using data_ptr() here (private API) so we can bypass the
// isDetached() and the replacement of a null pointer with _empty in
// both QString and QByteArray's data() and constData(). The result is
// the same if len != 0.
auto d = reinterpret_cast<typename T::iterator>(s.data_ptr().data());
const auto start = d;
Concatenable::appendTo(*this, d);
if constexpr (Concatenable::ExactSize) {
Q_UNUSED(start)
} else {
if (len != d - start) {
// this resize is necessary since we allocate a bit too much
// when dealing with variable sized 8-bit encodings
s.resize(d - start);
}
}
return s;
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
jne 0x527a86
cmpq $0x0, 0x20(%r14)
jne 0x527a86
cmpq $0x0, 0x38(%r14)
jne 0x527a86
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x527b2b
movq 0x28(%r14), %rsi
addq 0x10(%r14), %rsi
addq 0x40(%r14), %rsi
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x10(%rbx)
movaps 0x4cbd9(%rip), %xmm0 # 0x574680
movups %xmm0, (%rbx)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x142b80
movq 0x8(%rbx), %r15
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x527add
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x527ad1
movq 0x1c7477(%rip), %rsi # 0x6eef48
leaq (%r12,%r12), %rdx
movq %r15, %rdi
callq 0x137aa0
leaq (%r15,%r12,2), %r15
movq 0x28(%r14), %r12
testq %r12, %r12
je 0x527b06
movq 0x20(%r14), %rsi
testq %rsi, %rsi
jne 0x527afa
movq 0x1c744e(%rip), %rsi # 0x6eef48
leaq (%r12,%r12), %rdx
movq %r15, %rdi
callq 0x137aa0
movq 0x40(%r14), %rdx
testq %rdx, %rdx
je 0x527b2b
leaq (%r15,%r12,2), %rdi
movq 0x38(%r14), %rsi
testq %rsi, %rsi
jne 0x527b23
movq 0x1c7425(%rip), %rsi # 0x6eef48
addq %rdx, %rdx
callq 0x137aa0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /qt[P]qtbase/src/corelib/text/qstringbuilder.h |
QX11Info::appUserTime() | quint32 QX11Info::appUserTime()
{
if (!qApp)
return 0;
QPlatformNativeInterface *native = qApp->platformNativeInterface();
if (!native)
return 0;
QScreen* screen = QGuiApplication::primaryScreen();
return static_cast<xcb_timestamp_t>(reinterpret_cast<quintptr>(native->nativeResourceForScreen("appusertime", screen)));
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movq 0x1c6828(%rip), %rax # 0x6ee968
xorl %ebx, %ebx
cmpq $0x0, (%rax)
je 0x5281a8
callq 0x13d240
testq %rax, %rax
je 0x5281a8
movq %rax, %r14
callq 0x137ee0
movq %rax, %rbx
leaq 0x9fe0b(%rip), %rsi # 0x5c7f6f
movq %rsp, %r15
movq %r15, %rdi
movq $-0x1, %rdx
callq 0x144940
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *0x70(%rax)
movq %rax, %rbx
movq (%r15), %rax
testq %rax, %rax
je 0x5281a8
lock
decl (%rax)
jne 0x5281a8
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x5281c4
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/platform/unix/qtx11extras.cpp |
bool QMetaType::registerConverter<QList<QXdgDBusImageStruct>, QIterable<QMetaSequence>, QtPrivate::QSequentialIterableConvertFunctor<QList<QXdgDBusImageStruct>>>(QtPrivate::QSequentialIterableConvertFunctor<QList<QXdgDBusImageStruct>>) | static bool registerConverter(UnaryFunction function)
{
static_assert((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn),
"QMetaType::registerConverter: At least one of the types must be a custom type.");
const QMetaType fromType = QMetaType::fromType<From>();
const QMetaType toType = QMetaType::fromType<To>();
auto converter = [function = std::move(function)](const void *from, void *to) -> bool {
const From *f = static_cast<const From *>(from);
To *t = static_cast<To *>(to);
auto &&r = function(*f);
if constexpr (std::is_same_v<q20::remove_cvref_t<decltype(r)>, std::optional<To>>) {
if (!r)
return false;
*t = *std::forward<decltype(r)>(r);
} else {
*t = std::forward<decltype(r)>(r);
}
return true;
};
return registerConverterImpl<From, To>(std::move(converter), fromType, toType);
} | endbr64
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movb $-0x56, (%r14)
leaq 0xb0(%rip), %rax # 0x54d0aa
movq %rax, 0x18(%r14)
leaq 0xc7(%rip), %rax # 0x54d0cc
movq %rax, 0x10(%r14)
leaq 0x1ac5b0(%rip), %rsi # 0x6f95c0
leaq 0x1a33e1(%rip), %rdx # 0x6f03f8
movq %r14, %rdi
callq 0x54d056
movl %eax, %ebx
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x54d037
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x54d051
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
| /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QArrayDataPointer<QXdgDBusImageStruct>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QXdgDBusImageStruct const**) | qsizetype constAllocatedCapacity() const noexcept { return d ? d->constAllocatedCapacity() : 0; } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x54da40
movq 0x8(%rax), %r9
movq 0x8(%rdi), %r8
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %r8
sarq $0x5, %r8
movq 0x10(%rdi), %rax
addq %r8, %rax
movq %r9, %r10
subq %rax, %r10
jmp 0x54da49
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %esi, %esi
jne 0x54da65
cmpq %rdx, %r8
jl 0x54da65
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rdx
addq %r9, %r9
xorl %eax, %eax
cmpq %r9, %rdx
jl 0x54da9d
retq
xorl %eax, %eax
cmpl $0x1, %esi
jne 0x54da64
cmpq %rdx, %r10
jl 0x54da64
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rsi
cmpq %r9, %rsi
jge 0x54dab3
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 0x54dab6
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QGenericArrayOps<QXdgDBusImageStruct>::eraseFirst() | void eraseFirst() noexcept
{
Q_ASSERT(this->isMutable());
Q_ASSERT(this->size);
this->begin()->~T();
++this->ptr;
--this->size;
} | endbr64
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x54dbd1
lock
decl (%rcx)
jne 0x54dbd1
movq 0x8(%rax), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
addq $0x20, 0x8(%rbx)
decq 0x10(%rbx)
popq %rbx
retq
| /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QStatusNotifierItemAdaptor::ProvideXdgActivationToken(QString const&) | void QStatusNotifierItemAdaptor::ProvideXdgActivationToken(const QString &token)
{
qCDebug(qLcTray) << token;
qputenv("XDG_ACTIVATION_TOKEN", token.toUtf8());
} | endbr64
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
callq 0x5489f0
movb 0x10(%rax), %cl
testb $0x1, %cl
je 0x54e666
movq 0x8(%rax), %rax
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x13ecf0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
testq %rsi, %rsi
jne 0x54e63f
movq 0x1a0909(%rip), %rsi # 0x6eef48
movq %r14, %rdi
callq 0x137cf0
movq 0x28(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x54e65c
movl $0x20, %esi
callq 0x13d680
leaq 0x28(%rsp), %rdi
callq 0x1391b0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x139340
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rsi
leaq 0x7eb51(%rip), %rdi # 0x5cd1d6
callq 0x140f50
movq (%r14), %rax
testq %rax, %rax
je 0x54e6ab
lock
decl (%rax)
jne 0x54e6ab
movq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x30(%rsp), %rax
jne 0x54e6c3
addq $0x38, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/platform/unix/dbustray/qstatusnotifieritemadaptor.cpp |
QXkbCommon::lookupStringNoKeysymTransformations(unsigned int) | QString QXkbCommon::lookupStringNoKeysymTransformations(xkb_keysym_t keysym)
{
QVarLengthArray<char, 32> chars(32);
const int size = xkb_keysym_to_utf8(keysym, chars.data(), chars.size());
if (size == 0)
return QString(); // the keysym does not have a Unicode representation
if (Q_UNLIKELY(size > chars.size())) {
chars.resize(size);
xkb_keysym_to_utf8(keysym, chars.data(), chars.size());
}
return QString::fromUtf8(chars.constData(), size - 1);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
leaq 0x20(%rsp), %r14
movaps 0x24351(%rip), %xmm0 # 0x574680
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movl $0x20, %eax
movq %rax, -0x18(%r14)
movq %r14, -0x8(%r14)
movq %rax, -0x10(%r14)
movl $0x20, %edx
movl %esi, %edi
movq %r14, %rsi
callq 0x148ed0
testl %eax, %eax
je 0x5503ad
movl %eax, %r15d
movslq %eax, %r12
cmpq %r12, 0x10(%rsp)
jl 0x5503f1
movq 0x18(%rsp), %r12
testl %r15d, %r15d
setg %al
cmpl $0x2, %r15d
movl $0x1, %esi
cmovgel %r15d, %esi
decl %esi
testq %r12, %r12
sete %cl
cmoveq %r12, %rsi
orb %al, %cl
jne 0x5503a0
movq %r12, %rdi
callq 0x13c0e0
movq %rax, %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1457d0
jmp 0x5503bb
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x5503cf
movq 0x8(%rsp), %rsi
callq 0x1387a0
movq %fs:0x28, %rax
cmpq 0x40(%rsp), %rax
jne 0x55042b
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r13
movq (%r13), %r8
cmpq %r12, %r8
cmovleq %r12, %r8
movl $0x20, %esi
movq %r13, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x307f02
movq %r12, 0x8(%r13)
movq 0x10(%r13), %rsi
movl %ebp, %edi
movq %r12, %rdx
callq 0x148ed0
jmp 0x55036d
callq 0x13a8c0
| /qt[P]qtbase/src/gui/platform/unix/qxkbcommon.cpp |
QXkbCommon::possibleKeyCombinations(xkb_state*, QKeyEvent const*, bool, bool) | QList<QKeyCombination> QXkbCommon::possibleKeyCombinations(xkb_state *state, const QKeyEvent *event,
bool superAsMeta, bool hyperAsMeta)
{
QList<QKeyCombination> result;
quint32 keycode = event->nativeScanCode();
if (!keycode)
return result;
Qt::KeyboardModifiers modifiers = event->modifiers();
xkb_keymap *keymap = xkb_state_get_keymap(state);
// turn off the modifier bits which doesn't participate in shortcuts
Qt::KeyboardModifiers notNeeded = Qt::KeypadModifier | Qt::GroupSwitchModifier;
modifiers &= ~notNeeded;
// create a fresh kb state and test against the relevant modifier combinations
ScopedXKBState scopedXkbQueryState(xkb_state_new(keymap));
xkb_state *queryState = scopedXkbQueryState.get();
if (!queryState) {
qCWarning(lcQpaKeyMapper) << Q_FUNC_INFO << "failed to compile xkb keymap";
return result;
}
// get kb state from the master state and update the temporary state
xkb_layout_index_t lockedLayout = xkb_state_serialize_layout(state, XKB_STATE_LAYOUT_LOCKED);
xkb_mod_mask_t latchedMods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LATCHED);
xkb_mod_mask_t lockedMods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED);
xkb_mod_mask_t depressedMods = xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED);
xkb_state_update_mask(queryState, depressedMods, latchedMods, lockedMods, 0, 0, lockedLayout);
// handle shortcuts for level three and above
xkb_layout_index_t layoutIndex = xkb_state_key_get_layout(queryState, keycode);
xkb_level_index_t levelIndex = 0;
if (layoutIndex != XKB_LAYOUT_INVALID) {
levelIndex = xkb_state_key_get_level(queryState, keycode, layoutIndex);
if (levelIndex == XKB_LEVEL_INVALID)
levelIndex = 0;
}
if (levelIndex <= 1)
xkb_state_update_mask(queryState, 0, latchedMods, lockedMods, 0, 0, lockedLayout);
xkb_keysym_t sym = xkb_state_key_get_one_sym(queryState, keycode);
if (sym == XKB_KEY_NoSymbol)
return result;
int baseQtKey = keysymToQtKey_internal(sym, modifiers, queryState, keycode, superAsMeta, hyperAsMeta);
if (baseQtKey)
result += QKeyCombination::fromCombined(baseQtKey + int(modifiers));
xkb_mod_index_t shiftMod = xkb_keymap_mod_get_index(keymap, "Shift");
xkb_mod_index_t altMod = xkb_keymap_mod_get_index(keymap, "Alt");
xkb_mod_index_t controlMod = xkb_keymap_mod_get_index(keymap, "Control");
xkb_mod_index_t metaMod = xkb_keymap_mod_get_index(keymap, "Meta");
Q_ASSERT(shiftMod < 32);
Q_ASSERT(altMod < 32);
Q_ASSERT(controlMod < 32);
xkb_mod_mask_t depressed;
int qtKey = 0;
// obtain a list of possible shortcuts for the given key event
for (uint i = 1; i < sizeof(ModsTbl) / sizeof(*ModsTbl) ; ++i) {
Qt::KeyboardModifiers neededMods = ModsTbl[i];
if ((modifiers & neededMods) == neededMods) {
if (i == 8) {
if (isLatin1(baseQtKey))
continue;
// add a latin key as a fall back key
sym = lookupLatinKeysym(state, keycode);
} else {
depressed = 0;
if (neededMods & Qt::AltModifier)
depressed |= (1 << altMod);
if (neededMods & Qt::ShiftModifier)
depressed |= (1 << shiftMod);
if (neededMods & Qt::ControlModifier)
depressed |= (1 << controlMod);
if (metaMod < 32 && neededMods & Qt::MetaModifier)
depressed |= (1 << metaMod);
xkb_state_update_mask(queryState, depressed, latchedMods, lockedMods, 0, 0, lockedLayout);
sym = xkb_state_key_get_one_sym(queryState, keycode);
}
if (sym == XKB_KEY_NoSymbol)
continue;
Qt::KeyboardModifiers mods = modifiers & ~neededMods;
qtKey = keysymToQtKey_internal(sym, mods, queryState, keycode, superAsMeta, hyperAsMeta);
if (!qtKey || qtKey == baseQtKey)
continue;
// catch only more specific shortcuts, i.e. Ctrl+Shift+= also generates Ctrl++ and +,
// but Ctrl++ is more specific than +, so we should skip the last one
bool ambiguous = false;
for (auto keyCombination : std::as_const(result)) {
if (keyCombination.key() == qtKey
&& (keyCombination.keyboardModifiers() & mods) == mods) {
ambiguous = true;
break;
}
}
if (ambiguous)
continue;
result += QKeyCombination::fromCombined(qtKey + int(mods));
}
}
return result;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rdi)
movl 0x44(%rdx), %ebp
testl %ebp, %ebp
je 0x5511bf
movl %r8d, %r13d
movq %rsi, %rbx
movl %ecx, 0x14(%rsp)
movq %rdx, %rdi
callq 0x144640
movl %eax, %r15d
movq %rbx, %rdi
callq 0x144140
movq %rax, %r12
movq %rax, %rdi
callq 0x141a20
movq %rax, %r14
testq %rax, %rax
je 0x5511b2
movl %r13d, 0x10(%rsp)
movq %r12, 0x38(%rsp)
movq %r15, 0x18(%rsp)
movq %rbx, %rdi
movl $0x40, %esi
callq 0x13bac0
movl %eax, %r13d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1446e0
movl %eax, %r15d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x1446e0
movl %eax, %r12d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1446e0
movl %r13d, 0x34(%rsp)
movl %r13d, (%rsp)
movq %r14, %rdi
movl %eax, %esi
movl %r15d, 0x30(%rsp)
movl %r15d, %edx
movl %r12d, 0x2c(%rsp)
movl %r12d, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x143230
movq %r14, %rdi
movl %ebp, %esi
callq 0x13d3a0
cmpl $-0x1, %eax
je 0x550eff
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x1479c0
incl %eax
cmpl $0x2, %eax
ja 0x550f1e
movl 0x34(%rsp), %eax
movl %eax, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
movl 0x30(%rsp), %edx
movl 0x2c(%rsp), %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x143230
movq %r14, %rdi
movl %ebp, %esi
callq 0x1444a0
testl %eax, %eax
movq 0x18(%rsp), %r12
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %edx
je 0x5511a8
movq %rbx, 0x58(%rsp)
andl $0x9fffffff, %r12d # imm = 0x9FFFFFFF
movzbl %dl, %r8d
movzbl %cl, %r9d
movl %eax, %edi
movl %r12d, %esi
movq %r14, %rdx
movl %ebp, %ecx
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
callq 0x5509b5
movl %eax, %r15d
testl %eax, %eax
je 0x550f93
leal (%r15,%r12), %eax
leaq 0x60(%rsp), %rdx
movl %eax, (%rdx)
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1ecf44
movq %rbx, %rdi
callq 0x1eccc0
leaq 0x69fa1(%rip), %rsi # 0x5baf3b
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x13f6f0
movl %eax, 0x18(%rsp)
leaq 0x50076(%rip), %rsi # 0x5a1028
movq %rbx, %rdi
callq 0x13f6f0
movl %eax, %r13d
leaq 0x7d150(%rip), %rsi # 0x5ce114
movq %rbx, %rdi
callq 0x13f6f0
movl %eax, 0xc(%rsp)
leaq 0x69f6a(%rip), %rsi # 0x5baf41
movq %rbx, %rdi
callq 0x13f6f0
movl $0x1, %edx
movl %r13d, %ecx
shll %cl, %edx
movl %edx, 0x54(%rsp)
movl $0x1, %edx
movl 0x18(%rsp), %ecx
shll %cl, %edx
movl %edx, 0x50(%rsp)
movl $0x1, %edx
movl $0x1, %esi
movl 0xc(%rsp), %ecx
shll %cl, %esi
movl %esi, 0x48(%rsp)
movl %eax, 0xc(%rsp)
movl %eax, %ecx
shll %cl, %edx
movl %edx, 0x4c(%rsp)
movq %r15, 0x38(%rsp)
leal -0x20(%r15), %eax
movl %eax, 0x44(%rsp)
movl $0x1, %r13d
movq %r12, 0x18(%rsp)
movl %r12d, %ebx
notl %ebx
xorl %r15d, %r15d
leaq 0x7d0ad(%rip), %rax # 0x5ce0f0
movl (%rax,%r13,4), %r12d
testl %ebx, %r12d
jne 0x551196
cmpq $0x8, %r13
jne 0x551072
cmpl $0xe0, 0x44(%rsp)
jb 0x5511a3
movq 0x58(%rsp), %rdi
movl %ebp, %esi
callq 0x13dd00
jmp 0x5510ed
movd %r12d, %xmm0
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
pand 0x7c6cc(%rip), %xmm0 # 0x5cd750
pcmpeqd 0x24884(%rip), %xmm0 # 0x575910
movmskps %xmm0, %eax
testb $0x8, %al
movl 0x54(%rsp), %ecx
cmovnel %r15d, %ecx
testb $0x4, %al
movl 0x50(%rsp), %edx
cmovnel %r15d, %edx
orl %ecx, %edx
testb $0x2, %al
movl 0x48(%rsp), %ecx
cmovnel %r15d, %ecx
orl %edx, %ecx
testb $0x1, %al
movl 0x4c(%rsp), %esi
cmovnel %r15d, %esi
cmpl $0x20, 0xc(%rsp)
cmovael %r15d, %esi
orl %ecx, %esi
movl 0x34(%rsp), %eax
movl %eax, (%rsp)
movq %r14, %rdi
movl 0x30(%rsp), %edx
movl 0x2c(%rsp), %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x143230
movq %r14, %rdi
movl %ebp, %esi
callq 0x1444a0
testl %eax, %eax
je 0x551196
notl %r12d
andl 0x18(%rsp), %r12d
movl %eax, %edi
movl %r12d, %esi
movq %r14, %rdx
movl %ebp, %ecx
movl 0x14(%rsp), %r8d
movl 0x10(%rsp), %r9d
callq 0x5509b5
testl %eax, %eax
sete %cl
cmpl 0x38(%rsp), %eax
sete %dl
orb %cl, %dl
jne 0x551196
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rsi
testq %rsi, %rsi
je 0x551175
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movl %r12d, %edx
andl $0x9e000000, %edx # imm = 0x9E000000
leaq (,%rsi,4), %rdi
xorl %r8d, %r8d
movl (%rcx,%r8), %r9d
movl %r9d, %r10d
andl $0x1ffffff, %r10d # imm = 0x1FFFFFF
cmpl %eax, %r10d
jne 0x55116c
andl %edx, %r9d
cmpl %r12d, %r9d
je 0x551196
addq $0x4, %r8
cmpq %r8, %rdi
jne 0x551151
addl %r12d, %eax
movl %eax, 0x60(%rsp)
movq 0x20(%rsp), %r12
movq %r12, %rdi
leaq 0x60(%rsp), %rdx
callq 0x1ecf44
movq %r12, %rdi
callq 0x1eccc0
incq %r13
cmpq $0x9, %r13
jne 0x55103c
testq %r14, %r14
je 0x5511bf
movq %r14, %rdi
callq 0x13b010
jmp 0x5511bf
callq 0x145a30
movb 0x11(%rax), %cl
testb $0x1, %cl
jne 0x5511ed
movq %fs:0x28, %rax
cmpq 0xa0(%rsp), %rax
jne 0x55131b
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rax), %rax
leaq 0x60(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x80(%rsp), %r15
movq %r15, %rdi
callq 0x144250
movq (%r15), %r15
movq $-0x1, %rsi
leaq 0x7cef7(%rip), %rax # 0x5ce126
cmpb $0x0, 0x1(%rsi,%rax)
leaq 0x1(%rsi), %rsi
jne 0x55122f
leaq 0x7cee5(%rip), %rdx # 0x5ce126
leaq 0x88(%rsp), %r12
movq %r12, %rdi
callq 0x1457d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x1455b0
movq (%r12), %rax
testq %rax, %rax
je 0x551281
lock
decl (%rax)
jne 0x551281
movq 0x88(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x80(%rsp), %r15
cmpb $0x1, 0x30(%r15)
jne 0x5512a5
movq %r15, %rdi
movl $0x20, %esi
callq 0x13d680
movq 0x80(%rsp), %r15
leaq 0x7cee8(%rip), %rdx # 0x5ce194
leaq 0x88(%rsp), %r12
movl $0x1c, %esi
movq %r12, %rdi
callq 0x1457d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x1455b0
movq (%r12), %rax
testq %rax, %rax
je 0x5512f1
lock
decl (%rax)
jne 0x5512f1
movq 0x88(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x80(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x551309
movl $0x20, %esi
callq 0x13d680
leaq 0x80(%rsp), %rdi
callq 0x1391b0
jmp 0x5511a3
callq 0x13a8c0
| /qt[P]qtbase/src/gui/platform/unix/qxkbcommon.cpp |
QXkbCommon::setXkbContext(QPlatformInputContext*, xkb_context*) | void QXkbCommon::setXkbContext(QPlatformInputContext *inputContext, struct xkb_context *context)
{
if (!inputContext || !context)
return;
const char *const inputContextClassName = "QComposeInputContext";
const char *const normalizedSignature = "setXkbContext(xkb_context*)";
if (inputContext->objectName() != QLatin1StringView(inputContextClassName))
return;
static const QMetaMethod setXkbContext = [&]() {
int methodIndex = inputContext->metaObject()->indexOfMethod(normalizedSignature);
QMetaMethod method = inputContext->metaObject()->method(methodIndex);
Q_ASSERT(method.isValid());
if (!method.isValid())
qCWarning(lcQpaKeyMapper) << normalizedSignature << "not found on" << inputContextClassName;
return method;
}();
if (!setXkbContext.isValid())
return;
setXkbContext.invoke(inputContext, Qt::DirectConnection, Q_ARG(struct xkb_context*, context));
} | endbr64
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %fs:0x28, %rcx
movq %rcx, 0x50(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x551551
movq %rdi, %rax
leaq 0x7cd74(%rip), %rcx # 0x5ce1dd
movq %rcx, 0x8(%rsp)
leaq 0x7cd7d(%rip), %rcx # 0x5ce1f2
movq %rcx, (%rsp)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x138780
movb $0x1, %bl
cmpq $0x14, 0x10(%r14)
jne 0x5514b2
movq 0x28(%rsp), %rsi
leaq 0x7cd3f(%rip), %rcx # 0x5ce1dd
movl $0x14, %edi
movl $0x14, %edx
callq 0x1373e0
movl %eax, %ebx
xorb $0x1, %bl
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x5514d5
lock
decl (%rax)
jne 0x5514d5
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
testb %bl, %bl
jne 0x551551
movb 0x1bc289(%rip), %al # 0x70d768
testb %al, %al
je 0x55156e
movq 0x1bc26a(%rip), %rdi # 0x70d758
testq %rdi, %rdi
je 0x551551
movq 0x18(%rsp), %rdx
leaq 0x30(%rsp), %rax
leaq 0x40(%rsp), %r10
xorl %ecx, %ecx
movq %rcx, -0x20(%r10)
leaq 0x10(%rsp), %rsi
movq %rsi, -0x18(%r10)
movq %rcx, -0x10(%r10)
leaq 0x7ccf2(%rip), %rsi # 0x5ce20e
movq %rsi, -0x8(%r10)
movq %rcx, (%r10)
leaq 0x1a83a6(%rip), %rcx # 0x6f98d0
movq %rcx, 0x8(%r10)
movq 0x1bc22b(%rip), %rsi # 0x70d760
leaq 0x20(%rsp), %r9
movl $0x2, %r8d
movl $0x1, %ecx
pushq %r10
pushq %rax
callq 0x1462c0
addq $0x10, %rsp
movq %fs:0x28, %rax
cmpq 0x50(%rsp), %rax
jne 0x551569
addq $0x58, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
callq 0x164230
jmp 0x5514e7
nop
| /qt[P]qtbase/src/gui/platform/unix/qxkbcommon.cpp |
qt_alphamapblit_generic(QRasterBuffer*, int, int, QRgba64 const&, unsigned char const*, int, int, int, QClipData const*, bool) | static void qt_alphamapblit_generic(QRasterBuffer *rasterBuffer,
int x, int y, const QRgba64 &color,
const uchar *map,
int mapWidth, int mapHeight, int mapStride,
const QClipData *clip, bool useGammaCorrection)
{
if (color.isTransparent())
return;
const QColorTrcLut *colorProfile = nullptr;
if (useGammaCorrection)
colorProfile = QGuiApplicationPrivate::instance()->colorProfileForA8Text();
QRgba64 srcColor = color;
if (colorProfile && color.isOpaque())
srcColor = colorProfile->toLinear(srcColor);
alignas(8) Q_DECL_UNINITIALIZED QRgba64 buffer[BufferSize];
const DestFetchProc64 destFetch64 = destFetchProc64[rasterBuffer->format];
const DestStoreProc64 destStore64 = destStoreProc64[rasterBuffer->format];
if (!clip) {
for (int ly = 0; ly < mapHeight; ++ly) {
int i = x;
int length = mapWidth;
while (length > 0) {
int l = qMin(BufferSize, length);
QRgba64 *dest = destFetch64(buffer, rasterBuffer, i, y + ly, l);
qt_alphamapblit_generic_oneline(map + i - x, l,
srcColor, dest, color,
colorProfile);
if (destStore64)
destStore64(rasterBuffer, i, y + ly, dest, l);
length -= l;
i += l;
}
map += mapStride;
}
} else {
int bottom = qMin(y + mapHeight, rasterBuffer->height());
int top = qMax(y, 0);
map += (top - y) * mapStride;
const_cast<QClipData *>(clip)->initialize();
for (int yp = top; yp<bottom; ++yp) {
const QClipData::ClipLine &line = clip->m_clipLines[yp];
for (int i=0; i<line.count; ++i) {
const QT_FT_Span &clip = line.spans[i];
int start = qMax<int>(x, clip.x);
int end = qMin<int>(x + mapWidth, clip.x + clip.len);
if (end <= start)
continue;
Q_ASSERT(end - start <= BufferSize);
QRgba64 *dest = destFetch64(buffer, rasterBuffer, start, clip.y, end - start);
qt_alphamapblit_generic_oneline(map + start - x, end - start,
srcColor, dest, color,
colorProfile);
if (destStore64)
destStore64(rasterBuffer, start, clip.y, dest, end - start);
} // for (i -> line.count)
map += mapStride;
} // for (yp -> bottom)
}
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4078, %rsp # imm = 0x4078
movl %r9d, 0x4(%rsp)
movq %r8, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %esi, (%rsp)
movq %fs:0x28, %rax
movq %rax, 0x4070(%rsp)
movq %rcx, 0x48(%rsp)
movq (%rcx), %rcx
movq %rcx, %rax
shrq $0x30, %rax
je 0x5535f8
movq %rdi, %r14
movq 0x40c0(%rsp), %r15
cmpb $0x0, 0x40c8(%rsp)
je 0x553348
movq 0x19cb08(%rip), %rax # 0x6efdc8
movq (%rax), %rdi
callq 0x1371a0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq (%rax), %rdx
movq %rcx, 0x28(%rsp)
testq %rcx, %rcx
je 0x55334f
movq %rdx, %rax
shrq $0x30, %rax
cmpl $0xffff, %eax # imm = 0xFFFF
jb 0x55361d
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rdx, %xmm0
movdqa %xmm0, %xmm1
psrlw $0x8, %xmm1
psubw %xmm1, %xmm0
movdqa %xmm0, %xmm1
psrlw $0x4, %xmm1
pextrw $0x2, %xmm1, %ecx
pextrw $0x1, %xmm1, %edx
pextrw $0x0, %xmm1, %esi
pinsrw $0x0, (%rax,%rsi,2), %xmm0
pinsrw $0x1, (%rax,%rdx,2), %xmm0
pinsrw $0x2, (%rax,%rcx,2), %xmm0
movdqa %xmm0, %xmm1
psrlw $0x8, %xmm1
paddw %xmm0, %xmm1
movq %xmm1, 0x20(%rsp)
jmp 0x55335d
movq %rcx, 0x20(%rsp)
jmp 0x553354
movq %rdx, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movl 0x40b8(%rsp), %ebx
movl 0x40b0(%rsp), %r12d
movl 0x10(%r14), %eax
leaq 0x1914a9(%rip), %rcx # 0x6e4820
movq (%rcx,%rax,8), %rcx
movq %rcx, 0x60(%rsp)
leaq 0x1a6b89(%rip), %rcx # 0x6f9f10
movq (%rcx,%rax,8), %rax
movq %rax, 0x50(%rsp)
testq %r15, %r15
movq %r14, 0x58(%rsp)
je 0x553505
movq 0x8(%rsp), %rcx
addl %ecx, %r12d
movl 0x24(%r14), %eax
cmpl %eax, %r12d
cmovgel %eax, %r12d
xorl %ebp, %ebp
testl %ecx, %ecx
cmovgl %ecx, %ebp
movq %r15, %rdi
callq 0x2b92d2
cmpl %r12d, %ebp
jge 0x5535f8
movl %ebp, %ecx
subl 0x8(%rsp), %ebp
imull %ebx, %ebp
movslq %ebp, %rax
addq %rax, 0x10(%rsp)
movl (%rsp), %eax
addl %eax, 0x4(%rsp)
cltq
negq %rax
movq %rax, 0x68(%rsp)
movslq %ebx, %rax
movq %rax, 0x8(%rsp)
movl %r12d, %eax
movq %rax, 0x38(%rsp)
movq 0x8(%r15), %rdx
movq %rcx, 0x40(%rsp)
movq %rcx, %rax
shlq $0x4, %rax
cmpl $0x0, (%rdx,%rax)
jle 0x5534db
addq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x68(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl $0x8, %r12d
xorl %ebx, %ebx
movq %rdx, 0x30(%rsp)
movq 0x8(%rdx), %r13
movl -0x8(%r13,%r12), %eax
movl (%rsp), %ebp
cmpl %ebp, %eax
cmovgl %eax, %ebp
addl -0x4(%r13,%r12), %eax
movl 0x4(%rsp), %ecx
movl %ecx, %r15d
cmpl %eax, %ecx
jl 0x55345b
movl %eax, %r15d
subl %ebp, %r15d
jle 0x5534c8
movl (%r13,%r12), %ecx
leaq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl %ebp, %edx
movl %r15d, %r8d
callq *0x60(%rsp)
movq %rax, %r14
movslq %ebp, %rdi
addq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %r8
movl %r15d, %esi
movq 0x20(%rsp), %rdx
movq %r14, %rcx
movq 0x28(%rsp), %r9
callq 0x56ed43
movq 0x30(%rsp), %rdx
cmpq $0x0, 0x50(%rsp)
je 0x5534c8
movl (%r13,%r12), %edx
movq 0x58(%rsp), %rdi
movl %ebp, %esi
movq %r14, %rcx
movl %r15d, %r8d
callq *0x50(%rsp)
movq 0x30(%rsp), %rdx
incq %rbx
movslq (%rdx), %rax
addq $0x10, %r12
cmpq %rax, %rbx
jl 0x553437
movq 0x8(%rsp), %rax
addq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rcx
incq %rcx
cmpq 0x38(%rsp), %rcx
movq 0x40c0(%rsp), %r15
jne 0x5533fb
jmp 0x5535f8
testl %r12d, %r12d
jle 0x5535f8
movslq (%rsp), %rax
negq %rax
movq %rax, 0x38(%rsp)
movslq %ebx, %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x58(%rsp), %rbx
cmpl $0x0, 0x4(%rsp)
jle 0x5535d3
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
leal (%rcx,%rax), %r15d
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movl (%rsp), %ebp
movl 0x4(%rsp), %r12d
movl $0x800, %eax # imm = 0x800
cmpl %eax, %r12d
movl $0x800, %r14d # imm = 0x800
cmovbl %r12d, %r14d
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r15d, %ecx
movl %r14d, %r8d
callq *0x60(%rsp)
movq %rax, %r13
movslq %ebp, %rdi
addq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %r8
movl %r14d, %esi
movq 0x20(%rsp), %rdx
movq %r13, %rcx
movq 0x28(%rsp), %r9
callq 0x56ed43
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x5535cb
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %r13, %rcx
movl %r14d, %r8d
callq *%rax
addl %r14d, %ebp
subl %r14d, %r12d
jg 0x553563
movq 0x40(%rsp), %rax
addq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
incl %ecx
movl 0x40b0(%rsp), %eax
movq %rcx, 0x18(%rsp)
cmpl %eax, %ecx
jne 0x553530
movq %fs:0x28, %rax
cmpq 0x4070(%rsp), %rax
jne 0x553627
addq $0x4078, %rsp # imm = 0x4078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0x20(%rsp)
jmp 0x55335d
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_color_argb(int, QT_FT_Span_ const*, void*) | static void blend_color_argb(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, nullptr, 0);
const uint color = data->solidColor.rgba();
if (op.mode == QPainter::CompositionMode_Source) {
// inline for performance
while (count--) {
uint *target = ((uint *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
if (spans->coverage == 255) {
qt_memfill(target, color, spans->len);
#ifdef __SSE2__
} else if (spans->len > 16) {
op.funcSolid(target, spans->len, color, spans->coverage);
#endif
} else {
uint c = BYTE_MUL(color, spans->coverage);
int ialpha = 255 - spans->coverage;
for (int i = 0; i < spans->len; ++i)
target[i] = c + BYTE_MUL(target[i], ialpha);
}
++spans;
}
return;
}
const auto funcSolid = op.funcSolid;
auto function = [=] (int cStart, int cEnd) {
for (int c = cStart; c < cEnd; ++c) {
uint *target = ((uint *)data->rasterBuffer->scanLine(spans[c].y)) + spans[c].x;
funcSolid(target, spans[c].len, color, spans[c].coverage);
}
};
QT_THREAD_PARALLEL_FILLS(function);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
leaq 0x7b01c(%rip), %rsi # 0x5ce8d0
leaq 0x30(%rsp), %r12
movl $0xb0, %edx
movq %r12, %rdi
callq 0x137aa0
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x556d77
leaq 0x98(%r14), %rdi
callq 0x148190
movl %eax, %ebp
cmpl $0x3, (%r12)
jne 0x5539f8
testl %ebx, %ebx
je 0x553bb4
movabsq $0xff00ff00ff00ff, %r12 # imm = 0xFF00FF00FF00FF
movabsq $0x80008000800080, %r13 # imm = 0x80008000800080
movl %ebp, %eax
movq %rax, %rcx
shlq $0x18, %rcx
orq %rax, %rcx
andq %r12, %rcx
movq %rcx, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%r14), %rax
movslq 0x8(%r15), %rcx
imulq 0x28(%rax), %rcx
addq 0x38(%rax), %rcx
movslq (%r15), %rax
leaq (%rcx,%rax,4), %rdi
movzbl 0xc(%r15), %ecx
movslq 0x4(%r15), %rdx
cmpl $0xff, %ecx
je 0x553962
cmpl $0x11, %edx
jl 0x55396c
movl %edx, %esi
movl %ebp, %edx
callq *0x8(%rsp)
jmp 0x5539e5
movl %ebp, %esi
callq *0x1b9e06(%rip) # 0x70d770
jmp 0x5539e5
testl %edx, %edx
jle 0x5539e5
movl %ecx, %edx
imulq 0x10(%rsp), %rdx
movq %rdx, %rax
shrq $0x8, %rax
andq %r12, %rax
addq %r13, %rdx
addq %rax, %rdx
shrq $0x8, %rdx
andq %r12, %rdx
movq %rdx, %rax
shrq $0x18, %rax
orl %edx, %eax
notb %cl
movzbl %cl, %ecx
xorl %edx, %edx
movl (%rdi,%rdx,4), %esi
movq %rsi, %r8
shlq $0x18, %r8
orq %rsi, %r8
andq %r12, %r8
imulq %rcx, %r8
movq %r8, %rsi
shrq $0x8, %rsi
andq %r12, %rsi
addq %r13, %r8
addq %rsi, %r8
shrq $0x8, %r8
andq %r12, %r8
movq %r8, %rsi
shrq $0x18, %rsi
orl %r8d, %esi
addl %eax, %esi
movl %esi, (%rdi,%rdx,4)
incq %rdx
movslq 0x4(%r15), %rsi
cmpq %rsi, %rdx
jl 0x55399f
decl %ebx
addq $0x10, %r15
testl %ebx, %ebx
jne 0x553928
jmp 0x553bb4
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq 0x50(%rsp), %r13
movq %rax, 0xf8(%rsp)
movq %r14, 0xe0(%rsp)
movq %r15, 0xe8(%rsp)
movq %r13, 0xf0(%rsp)
movl %ebp, 0xf8(%rsp)
leal 0x20(%rbx), %eax
leal 0x5f(%rbx), %r12d
testl %eax, %eax
cmovnsl %eax, %r12d
callq 0x138da0
cmpl $0x60, %ebx
jl 0x553b75
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x553b79
movq (%r14), %rax
movl 0x10(%rax), %eax
shlq $0x6, %rax
leaq 0x1a1828(%rip), %rcx # 0x6f5290
cmpl $0x3, 0x4(%rcx,%rax)
jl 0x553b79
callq 0x141020
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x13c2a0
testb %al, %al
jne 0x553b79
sarl $0x6, %r12d
movq %r12, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, (%rdi)
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x13c9f0
cmpl $0x2, %r12d
movl $0x1, %eax
cmovgel %r12d, %eax
negl %eax
movl %eax, 0x10(%rsp)
movq 0x19b5f4(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
movq 0x18(%rsp), %r14
movl %ebx, %eax
subl %r12d, %eax
movq 0x8(%rsp), %rcx
addl %r13d, %ecx
cltd
idivl %ecx
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r15
movb $0x1, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, (%r15)
movl $0x20, %edi
callq 0x1387d0
leaq 0x1be01(%rip), %rcx # 0x56f91a
movq %rcx, (%rax)
movl %r12d, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x1393d0
addl %ebp, %r12d
decl %r13d
cmpl %r13d, 0x10(%rsp)
jne 0x553add
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x143df0
movq %rbx, %rdi
callq 0x13f120
jmp 0x553bb4
testl %ebx, %ebx
jle 0x553bb4
movl %ebx, %ebx
shlq $0x4, %rbx
xorl %r12d, %r12d
movq (%r14), %rax
movslq 0x8(%r15,%r12), %rcx
imulq 0x28(%rax), %rcx
addq 0x38(%rax), %rcx
movslq (%r15,%r12), %rax
leaq (%rcx,%rax,4), %rdi
movl 0x4(%r15,%r12), %esi
movzbl 0xc(%r15,%r12), %ecx
movl %ebp, %edx
callq *%r13
addq $0x10, %r12
cmpq %r12, %rbx
jne 0x553b82
movq %fs:0x28, %rax
cmpq 0x100(%rsp), %rax
jne 0x553bd9
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_color_generic_rgb64(int, QT_FT_Span_ const*, void*) | static void blend_color_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
#if QT_CONFIG(raster_64bit)
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, nullptr, 0);
if (!op.funcSolid64) {
qCDebug(lcQtGuiDrawHelper, "blend_color_generic_rgb64: unsupported 64bit blend attempted, falling back to 32-bit");
return blend_color_generic(count, spans, userData);
}
const QRgba64 color = data->solidColor.rgba64();
const bool solidFill = op.mode == QPainter::CompositionMode_Source;
const QPixelLayout::BPP bpp = qPixelLayouts[data->rasterBuffer->format].bpp;
auto function = [=, &op] (int cStart, int cEnd)
{
alignas(16) Q_DECL_UNINITIALIZED QRgba64 buffer[BufferSize];
for (int c = cStart; c < cEnd; ++c) {
int x = spans[c].x;
int length = spans[c].len;
if (solidFill && bpp >= QPixelLayout::BPP8 && spans[c].coverage == 255 && length && op.destStore64) {
// If dest doesn't matter we don't need to bother with blending or converting all the identical pixels
op.destStore64(data->rasterBuffer, x, spans[c].y, &color, 1);
spanfill_from_first(data->rasterBuffer, bpp, x, spans[c].y, length);
length = 0;
}
while (length) {
int l = qMin(BufferSize, length);
QRgba64 *dest = op.destFetch64(buffer, data->rasterBuffer, x, spans[c].y, l);
op.funcSolid64(dest, l, color, spans[c].coverage);
if (op.destStore64)
op.destStore64(data->rasterBuffer, x, spans[c].y, dest, l);
length -= l;
x += l;
}
}
};
QT_THREAD_PARALLEL_FILLS(function);
#else
blend_color_generic(count, spans, userData);
#endif
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r12
movq %rsi, %r14
movl %edi, %ebp
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
leaq 0x794e2(%rip), %rsi # 0x5ce8d0
leaq 0x50(%rsp), %r15
movl $0xb0, %edx
movq %r15, %rdi
callq 0x137aa0
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x556d77
cmpq $0x0, 0x48(%r15)
je 0x5554c7
movabsq $-0x5555555555555556, %r13 # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x98(%r12), %rdi
callq 0x143d10
movq (%r12), %rcx
movl 0x10(%rcx), %ecx
shlq $0x6, %rcx
cmpl $0x3, 0x50(%rsp)
leaq 0x19fe48(%rip), %rbx # 0x6f5290
movl 0x4(%rbx,%rcx), %ecx
movq %r13, 0x38(%rsp)
movq %r15, 0x28(%rsp)
movq %r14, 0x30(%rsp)
sete 0x38(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r12, 0x40(%rsp)
movq %rax, 0x48(%rsp)
leal 0x20(%rbp), %eax
leal 0x5f(%rbp), %r14d
testl %eax, %eax
cmovnsl %eax, %r14d
callq 0x138da0
cmpl $0x60, %ebp
jl 0x5554b7
movq %rax, %r15
testq %rax, %rax
je 0x5554b7
movq (%r12), %rax
movl 0x10(%rax), %eax
shlq $0x6, %rax
cmpl $0x3, 0x4(%rbx,%rax)
jl 0x5554b7
callq 0x141020
movq %r15, %rdi
movq %rax, %rsi
callq 0x13c2a0
testb %al, %al
je 0x55553e
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x570a32
jmp 0x555515
callq 0x56df86
movb 0x1b82c6(%rip), %al # 0x70d798
testb $0x1, %al
je 0x555508
movq 0x1b82b3(%rip), %rax # 0x70d790
leaq 0x28(%rsp), %rdi
movl $0x2, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x79715(%rip), %rsi # 0x5cec16
xorl %eax, %eax
callq 0x13c920
movl %ebp, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x55362c
movq %fs:0x28, %rax
cmpq 0x100(%rsp), %rax
jne 0x555624
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
sarl $0x6, %r14d
leaq 0x20(%rsp), %rdi
movq %r13, (%rdi)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x13c9f0
cmpl $0x2, %r14d
movl $0x1, %eax
cmovgel %r14d, %eax
negl %eax
movl %eax, 0xc(%rsp)
movq 0x199b52(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq %r15, 0x10(%rsp)
xorl %r15d, %r15d
movl %ebp, %eax
subl %r15d, %eax
leal (%r14,%r12), %ecx
cltd
idivl %ecx
movq %r14, %rbx
movq %rbp, %r14
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r13
movb $0x1, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%r13)
movl $0x20, %edi
callq 0x1387d0
leaq 0x1b5f6(%rip), %rcx # 0x570bb4
movq %rcx, (%rax)
movl %r15d, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x1393d0
addl %ebp, %r15d
movq %r14, %rbp
movq %rbx, %r14
decl %r12d
cmpl %r12d, 0xc(%rsp)
jne 0x55557f
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x143df0
movq %rbx, %rdi
callq 0x13f120
jmp 0x555515
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
qt_rectfill_fp32x4(QRasterBuffer*, int, int, int, int, QRgba64 const&) | static void qt_rectfill_fp32x4(QRasterBuffer *rasterBuffer,
int x, int y, int width, int height,
const QRgba64 &color)
{
const auto store = qStoreFromRGBA64PM[rasterBuffer->format];
QRgbaFloat32 c;
store(reinterpret_cast<uchar *>(&c), &color, 0, 1, nullptr, nullptr);
qt_rectfill<QRgbaFloat32>(reinterpret_cast<QRgbaFloat32 *>(rasterBuffer->buffer()),
c, x, y, width, height, rasterBuffer->bytesPerLine());
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movl 0x10(%rdi), %eax
leaq 0x19fbc0(%rip), %rcx # 0x6f5bd0
movq (%rcx,%rax,8), %rax
pcmpeqd %xmm0, %xmm0
movq %rsp, %r13
movdqa %xmm0, (%r13)
movq %r13, %rdi
movq %r9, %rsi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *%rax
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
movq 0x28(%r12), %rcx
movslq %r15d, %rdx
shlq $0x4, %rdx
addq 0x38(%r12), %rdx
movslq %r14d, %rax
imulq %rcx, %rax
addq %rdx, %rax
movl %ecx, %esi
movslq %ebp, %rdx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpq %rdi, %rsi
jne 0x5560a5
movslq %ebx, %rsi
imulq %rdx, %rsi
testq %rsi, %rsi
je 0x5561f1
leaq 0x7(%rsi), %rdx
leaq 0xe(%rsi), %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x3, %rcx
andl $0x7, %esi
leaq 0x78275(%rip), %rdx # 0x5ce310
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
testl %ebx, %ebx
jle 0x5561f1
leaq 0x7(%rdx), %rsi
addq $0xe, %rdx
testq %rsi, %rsi
cmovnsq %rsi, %rdx
sarq $0x3, %rdx
movl %ebp, %esi
andl $0x7, %esi
leaq 0x78224(%rip), %rdi # 0x5ce2f0
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
testl %ebp, %ebp
je 0x55616f
movslq (%rdi,%rsi,4), %r8
addq %rdi, %r8
jmpq *%r8
movq %rax, %r8
movq %rdx, %r9
jmp 0x556122
movq %rax, %r8
movq %rdx, %r9
jmp 0x556142
movq %rax, %r8
movq %rdx, %r9
jmp 0x556152
movq %rax, %r8
movq %rdx, %r9
jmp 0x55614a
movq %rax, %r8
movq %rdx, %r9
jmp 0x55612a
movq %rax, %r8
movq %rdx, %r10
jmp 0x55615d
movq %rax, %r8
movq %rdx, %r9
jmp 0x55613a
movq %rax, %r8
movq %rdx, %r9
jmp 0x556132
movaps %xmm0, (%r8)
addq $0x10, %r8
movaps %xmm0, (%r8)
addq $0x10, %r8
movaps %xmm0, (%r8)
addq $0x10, %r8
movaps %xmm0, (%r8)
addq $0x10, %r8
movaps %xmm0, (%r8)
addq $0x10, %r8
movaps %xmm0, (%r8)
addq $0x10, %r8
movaps %xmm0, (%r8)
addq $0x10, %r8
movq %r9, %r10
movaps %xmm0, (%r8)
addq $0x10, %r8
leaq -0x1(%r10), %r9
cmpq $0x1, %r10
jg 0x556122
addq %rcx, %rax
decl %ebx
jne 0x5560cf
jmp 0x5561f1
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps %xmm2, (%rax)
addq $0x10, %rax
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps %xmm2, (%rax)
addq $0x10, %rax
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps %xmm2, (%rax)
addq $0x10, %rax
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps %xmm2, (%rax)
addq $0x10, %rax
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps %xmm2, (%rax)
addq $0x10, %rax
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps %xmm2, (%rax)
addq $0x10, %rax
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps %xmm2, (%rax)
addq $0x10, %rax
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps %xmm2, (%rax)
addq $0x10, %rax
leaq -0x1(%rcx), %rdx
cmpq $0x1, %rcx
movq %rdx, %rcx
jg 0x55617c
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x556210
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.cpp |
blend_untransformed_argb(int, QT_FT_Span_ const*, void*) | static void blend_untransformed_argb(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
if (data->texture.format != QImage::Format_ARGB32_Premultiplied
&& data->texture.format != QImage::Format_RGB32) {
blend_untransformed_generic(count, spans, userData);
return;
}
const Operator op = getOperator(data, spans, count);
const int image_width = data->texture.width;
const int image_height = data->texture.height;
const int const_alpha = data->texture.const_alpha;
const int xoff = -qRound(-data->dx);
const int yoff = -qRound(-data->dy);
auto function = [=, &op] (int cStart, int cEnd)
{
for (int c = cStart; c < cEnd; ++c) {
if (!spans[c].len)
continue;
int x = spans[c].x;
int length = spans[c].len;
int sx = xoff + x;
int sy = yoff + spans[c].y;
if (sy >= 0 && sy < image_height && sx < image_width) {
if (sx < 0) {
x -= sx;
length += sx;
sx = 0;
}
if (sx + length > image_width)
length = image_width - sx;
if (length > 0) {
const int coverage = (spans[c].coverage * const_alpha) >> 8;
const uint *src = (const uint *)data->texture.scanLine(sy) + sx;
uint *dest = ((uint *)data->rasterBuffer->scanLine(spans[c].y)) + x;
op.func(dest, src, length, coverage);
}
}
}
};
QT_THREAD_PARALLEL_FILLS(function);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movq %fs:0x28, %rax
movq %rax, 0x120(%rsp)
movl 0xd0(%rdx), %eax
orl $0x2, %eax
cmpl $0x6, %eax
jne 0x5565b6
movabsq $-0x5555555555555556, %r13 # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x78500(%rip), %rsi # 0x5ce8d0
leaq 0x70(%rsp), %r12
movl $0xb0, %edx
movq %r12, %rdi
callq 0x137aa0
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x556d77
movl 0xb0(%rbx), %ebp
movl 0xb4(%rbx), %eax
movl 0xe8(%rbx), %ecx
movq %r13, 0x60(%rsp)
movq %r12, 0x40(%rsp)
movq %r14, 0x48(%rsp)
movupd 0x70(%rbx), %xmm0
movapd 0x1e34f(%rip), %xmm1 # 0x574770
movapd %xmm0, %xmm2
xorpd %xmm1, %xmm2
andpd %xmm1, %xmm2
orpd 0x1e34b(%rip), %xmm2 # 0x574780
subpd %xmm0, %xmm2
cvttpd2dq %xmm2, %xmm1
xorpd %xmm0, %xmm0
movapd %xmm1, 0x20(%rsp)
psubd %xmm1, %xmm0
movq %xmm0, 0x50(%rsp)
movl %eax, 0x8(%rsp)
movl %eax, 0x58(%rsp)
movl %ebp, 0x5c(%rsp)
movl %ecx, 0x14(%rsp)
movl %ecx, 0x60(%rsp)
movq %rbx, 0x68(%rsp)
leal 0x20(%r15), %eax
leal 0x5f(%r15), %r12d
testl %eax, %eax
cmovnsl %eax, %r12d
callq 0x138da0
cmpl $0x60, %r15d
jl 0x5565ec
movq %rax, 0x18(%rsp)
testq %rax, %rax
movl 0x8(%rsp), %r11d
je 0x5565fa
movq (%rbx), %rax
movl 0x10(%rax), %eax
shlq $0x6, %rax
leaq 0x19ede5(%rip), %rcx # 0x6f5290
cmpl $0x3, 0x4(%rcx,%rax)
jl 0x5565fa
callq 0x141020
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x13c2a0
movl 0x8(%rsp), %r11d
testb %al, %al
jne 0x5565fa
sarl $0x6, %r12d
movq %r12, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
movq %r13, (%rdi)
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x13c9f0
cmpl $0x2, %r12d
movl $0x1, %eax
cmovgel %r12d, %eax
negl %eax
movl %eax, 0x14(%rsp)
movq 0x198bb6(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
movq %r15, %rbx
movq 0x18(%rsp), %r15
movl %ebx, %eax
subl %r12d, %eax
movq 0x8(%rsp), %rcx
addl %r13d, %ecx
cltd
idivl %ecx
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r14
movb $0x1, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, (%r14)
movl $0x20, %edi
callq 0x1387d0
leaq 0x160ac(%rip), %rcx # 0x56c606
movq %rcx, (%rax)
movl %r12d, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x38(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r14)
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x1393d0
addl %ebp, %r12d
decl %r13d
cmpl %r13d, 0x14(%rsp)
jne 0x55651e
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x143df0
movq %r14, %rdi
callq 0x13f120
jmp 0x5566cd
movq %fs:0x28, %rax
cmpq 0x120(%rsp), %rax
jne 0x5566f2
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x556b13
testl %r15d, %r15d
movl 0x8(%rsp), %r11d
jle 0x5566cd
movl %r15d, %r15d
movdqa 0x20(%rsp), %xmm0
movd %xmm0, %r12d
pshufd $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %r13d
addq $0xc, %r14
movl -0x8(%r14), %ecx
testl %ecx, %ecx
je 0x5566c0
movslq -0x4(%r14), %rax
movl %eax, %esi
subl %r13d, %esi
js 0x5566c0
cmpl %r11d, %esi
jge 0x5566c0
movl -0xc(%r14), %edi
movl %edi, %r9d
subl %r12d, %r9d
cmpl %ebp, %r9d
jge 0x5566c0
testl %r9d, %r9d
movl $0x0, %r8d
cmovgl %r9d, %r8d
movl $0x0, %r10d
cmovsl %r9d, %r10d
addl %ecx, %r10d
leal (%r10,%r8), %ecx
movl %ebp, %edx
subl %r8d, %edx
cmpl %ebp, %ecx
cmovlel %r10d, %edx
testl %edx, %edx
jle 0x5566c0
testl %r9d, %r9d
cmovsl %r12d, %edi
movzbl (%r14), %ecx
imull 0x14(%rsp), %ecx
movl %esi, %esi
imulq 0xc8(%rbx), %rsi
sarl $0x8, %ecx
addq 0xa8(%rbx), %rsi
movl %r8d, %r8d
leaq (%rsi,%r8,4), %rsi
movq (%rbx), %r8
imulq 0x28(%r8), %rax
addq 0x38(%r8), %rax
movslq %edi, %rdi
leaq (%rax,%rdi,4), %rdi
callq *0x98(%rsp)
movl 0x8(%rsp), %r11d
addq $0x10, %r14
decq %r15
jne 0x556616
movq %fs:0x28, %rax
cmpq 0x120(%rsp), %rax
jne 0x5566f2
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_untransformed_generic(int, QT_FT_Span_ const*, void*) | static void blend_untransformed_generic(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, spans, count);
const int image_width = data->texture.width;
const int image_height = data->texture.height;
const int const_alpha = data->texture.const_alpha;
const int xoff = -qRound(-data->dx);
const int yoff = -qRound(-data->dy);
const bool solidSource = op.mode == QPainter::CompositionMode_Source && const_alpha == 256 && op.destFetch != destFetchARGB32P;
auto function = [=, &op] (int cStart, int cEnd)
{
alignas(16) Q_DECL_UNINITIALIZED uint buffer[BufferSize];
alignas(16) Q_DECL_UNINITIALIZED uint src_buffer[BufferSize];
for (int c = cStart; c < cEnd; ++c) {
if (!spans[c].len)
continue;
int x = spans[c].x;
int length = spans[c].len;
int sx = xoff + x;
int sy = yoff + spans[c].y;
const bool fetchDest = !solidSource || spans[c].coverage < 255;
if (sy >= 0 && sy < image_height && sx < image_width) {
if (sx < 0) {
x -= sx;
length += sx;
sx = 0;
}
if (sx + length > image_width)
length = image_width - sx;
if (length > 0) {
const int coverage = (spans[c].coverage * const_alpha) >> 8;
while (length) {
int l = qMin(BufferSize, length);
const uint *src = op.srcFetch(src_buffer, &op, data, sy, sx, l);
uint *dest = fetchDest ? op.destFetch(buffer, data->rasterBuffer, x, spans[c].y, l) : buffer;
op.func(dest, src, l, coverage);
if (op.destStore)
op.destStore(data->rasterBuffer, x, spans[c].y, dest, l);
x += l;
sx += l;
length -= l;
}
}
}
}
};
QT_THREAD_PARALLEL_FILLS(function);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r12
movq %rsi, %r14
movl %edi, %ebp
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
movabsq $-0x5555555555555556, %r13 # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x77d7e(%rip), %rsi # 0x5ce8d0
leaq 0x50(%rsp), %r15
movl $0xb0, %edx
movq %r15, %rdi
callq 0x137aa0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x556d77
movl 0xe8(%r12), %eax
movl (%r15), %ecx
xorl $0x3, %ecx
movl %eax, %edx
xorl $0x100, %edx # imm = 0x100
orl %ecx, %edx
sete %cl
leaq 0x69b(%rip), %rdx # 0x557231
cmpq %rdx, 0x8(%r15)
setne %dl
andb %cl, %dl
movq %r13, 0x38(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movupd 0x70(%r12), %xmm0
movapd 0x1dbb3(%rip), %xmm1 # 0x574770
movapd %xmm0, %xmm2
xorpd %xmm1, %xmm2
andpd %xmm1, %xmm2
orpd 0x1dbaf(%rip), %xmm2 # 0x574780
subpd %xmm0, %xmm2
cvttpd2dq %xmm2, %xmm0
xorpd %xmm1, %xmm1
psubd %xmm0, %xmm1
movq %xmm1, 0x30(%rsp)
movb %dl, 0x38(%rsp)
movq 0xb0(%r12), %xmm0
pshufd $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0x3c(%rsp)
movl %eax, 0x44(%rsp)
movq %r12, 0x48(%rsp)
leal 0x20(%rbp), %eax
leal 0x5f(%rbp), %r14d
testl %eax, %eax
cmovnsl %eax, %r14d
callq 0x138da0
cmpl $0x60, %ebp
jl 0x556c55
movq %rax, %rbx
testq %rax, %rax
je 0x556c55
movq (%r12), %rax
movl 0x10(%rax), %eax
shlq $0x6, %rax
leaq 0x19e656(%rip), %rcx # 0x6f5290
cmpl $0x3, 0x4(%rcx,%rax)
jl 0x556c55
callq 0x141020
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13c2a0
testb %al, %al
je 0x556c8c
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x55724a
movq %fs:0x28, %rax
cmpq 0x100(%rsp), %rax
jne 0x556d72
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
sarl $0x6, %r14d
leaq 0x18(%rsp), %rdi
movq %r13, (%rdi)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x13c9f0
cmpl $0x2, %r14d
movl $0x1, %eax
cmovgel %r14d, %eax
negl %eax
movl %eax, 0x4(%rsp)
movq 0x198404(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
movq %rbx, 0x8(%rsp)
movl %ebp, %eax
subl %r15d, %eax
leal (%r14,%r12), %ecx
cltd
idivl %ecx
movq %r14, %rbx
movq %rbp, %r14
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r13
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, (%r13)
movl $0x20, %edi
callq 0x1387d0
leaq 0x722(%rip), %rcx # 0x55742e
movq %rcx, (%rax)
movl %r15d, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r13)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x1393d0
addl %ebp, %r15d
movq %r14, %rbp
movq %rbx, %r14
decl %r12d
cmpl %r12d, 0x4(%rsp)
jne 0x556ccd
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x143df0
movq %rbx, %rdi
callq 0x13f120
jmp 0x556c63
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
getLinearGradientValues(LinearGradientValues*, QSpanData const*) | static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const QSpanData *data)
{
v->dx = data->gradient.linear.end.x - data->gradient.linear.origin.x;
v->dy = data->gradient.linear.end.y - data->gradient.linear.origin.y;
v->l = v->dx * v->dx + v->dy * v->dy;
v->off = 0;
if (v->l != 0) {
v->dx /= v->l;
v->dy /= v->l;
v->off = -v->dx * data->gradient.linear.origin.x - v->dy * data->gradient.linear.origin.y;
}
} | movsd 0xc0(%rsi), %xmm0
subsd 0xb0(%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd 0xc8(%rsi), %xmm1
subsd 0xb8(%rsi), %xmm1
movsd %xmm1, 0x8(%rdi)
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jne 0x5574c7
jnp 0x557500
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm0
movupd %xmm0, (%rdi)
movapd 0x1d291(%rip), %xmm1 # 0x574770
xorpd %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
mulsd 0xb8(%rsi), %xmm0
mulsd 0xb0(%rsi), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rdi)
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
qt_fetch_conical_gradient_rgb64(QRgba64*, Operator const*, QSpanData const*, int, int, int) | static const QRgba64 * QT_FASTCALL qt_fetch_conical_gradient_rgb64(QRgba64 *buffer, const Operator *, const QSpanData *data,
int y, int x, int length)
{
return qt_fetch_conical_gradient_template<GradientBase64, QRgba64>(buffer, data, y, x, length);
} | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cvtsi2sd %ecx, %xmm0
movsd 0x1c6cb(%rip), %xmm2 # 0x574c50
addsd %xmm2, %xmm0
cvtsi2sd %r8d, %xmm5
addsd %xmm2, %xmm5
movupd 0x50(%rdx), %xmm2
movupd 0x70(%rdx), %xmm3
movapd %xmm0, %xmm4
unpcklpd %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0]
mulpd %xmm2, %xmm4
addpd %xmm3, %xmm4
movupd 0x38(%rdx), %xmm2
movapd %xmm5, %xmm1
unpcklpd %xmm5, %xmm1 # xmm1 = xmm1[0],xmm5[0]
mulpd %xmm2, %xmm1
addpd %xmm4, %xmm1
movsd 0x48(%rdx), %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jne 0x5585d6
jnp 0x5586ca
movslq %r9d, %rax
leaq (%rbx,%rax,8), %r12
cmpq %rbx, %r12
jbe 0x558752
mulsd 0x60(%r14), %xmm0
addsd 0x68(%r14), %xmm0
mulsd %xmm5, %xmm2
addsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
movapd %xmm2, %xmm3
cmpneqsd %xmm0, %xmm3
andpd %xmm3, %xmm2
movsd 0x1c14d(%rip), %xmm0 # 0x574760
andnpd %xmm0, %xmm3
orpd %xmm2, %xmm3
leaq 0xa8(%r14), %r15
movq %rbx, %r13
movapd %xmm3, 0x10(%rsp)
movapd %xmm1, (%rsp)
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
divsd %xmm3, %xmm0
subsd 0xb0(%r14), %xmm0
divsd %xmm3, %xmm1
subsd 0xb8(%r14), %xmm1
callq 0x13a900
addsd 0xc0(%r14), %xmm0
mulsd 0x75c70(%rip), %xmm0 # 0x5ce2d8
addsd 0x1c0f0(%rip), %xmm0 # 0x574760
movq %r15, %rdi
callq 0x570e2c
movapd 0x10(%rsp), %xmm3
movapd (%rsp), %xmm1
movq %rax, (%r13)
movupd 0x38(%r14), %xmm0
addpd %xmm0, %xmm1
movsd 0x48(%r14), %xmm0
addsd %xmm0, %xmm3
addsd %xmm3, %xmm0
movapd %xmm3, %xmm2
cmpneqsd 0x29d7c(%rip), %xmm2 # 0x582428
andpd %xmm2, %xmm3
andnpd %xmm0, %xmm2
orpd %xmm2, %xmm3
addq $0x8, %r13
cmpq %r12, %r13
jb 0x558625
jmp 0x558752
movsd 0x60(%r14), %xmm4
ucomisd %xmm3, %xmm4
movslq %r9d, %rax
leaq (%rbx,%rax,8), %r12
jne 0x5585dd
jp 0x5585dd
testl %r9d, %r9d
jle 0x558752
leaq 0xa8(%r14), %r15
movupd 0xb0(%r14), %xmm0
subpd %xmm0, %xmm1
movq %rbx, %r13
movapd %xmm1, (%rsp)
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
callq 0x13a900
addsd 0xc0(%r14), %xmm0
mulsd 0x75bb2(%rip), %xmm0 # 0x5ce2d8
addsd 0x1c032(%rip), %xmm0 # 0x574760
movq %r15, %rdi
callq 0x570e2c
movapd (%rsp), %xmm1
movq %rax, (%r13)
movupd 0x38(%r14), %xmm0
addpd %xmm0, %xmm1
addq $0x8, %r13
cmpq %r12, %r13
jb 0x558703
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
qt_gradient_pixel_fixed(QGradientData const*, int) | static uint qt_gradient_pixel_fixed(const QGradientData *data, int fixed_pos)
{
int ipos = (fixed_pos + (FIXPT_SIZE / 2)) >> FIXPT_BITS;
return data->colorTable32[qt_gradient_clamp(data, ipos)];
} | subl $-0x80, %esi
sarl $0x8, %esi
movq 0x40(%rdi), %rax
cmpl $0x400, %esi # imm = 0x400
jb 0x558a66
movl (%rdi), %ecx
cmpl $0x1, %ecx
je 0x558a46
cmpl $0x2, %ecx
jne 0x558a5a
andl $0x3ff, %esi # imm = 0x3FF
jmp 0x558a66
movl $0x7ff, %ecx # imm = 0x7FF
andl %ecx, %esi
xorl %esi, %ecx
cmpl $0x400, %esi # imm = 0x400
cmovael %ecx, %esi
jmp 0x558a66
xorl %ecx, %ecx
testl %esi, %esi
movl $0x3ff, %esi # imm = 0x3FF
cmovsl %ecx, %esi
movl %esi, %ecx
movl (%rax,%rcx,4), %eax
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformed_fetcher<(TextureBlendType)2, (QPixelLayout::BPP)6, unsigned int>(unsigned int*, QSpanData const*, int, int, int) | static void QT_FASTCALL fetchTransformed_fetcher(T *buffer, const QSpanData *data,
int y, int x, int length)
{
static_assert(blendType == BlendTransformed || blendType == BlendTransformedTiled);
const QTextureData &image = data->texture;
const qreal cx = x + qreal(0.5);
const qreal cy = y + qreal(0.5);
constexpr bool useFetch = (bpp < QPixelLayout::BPP32) && sizeof(T) == sizeof(uint);
const QPixelLayout *layout = &qPixelLayouts[data->texture.format];
if (!useFetch)
Q_ASSERT(layout->bpp == bpp || (layout->bpp == QPixelLayout::BPP16FPx4 && bpp == QPixelLayout::BPP64));
// When templated 'fetch' should be inlined at compile time:
const Fetch1PixelFunc fetch1 = (bpp == QPixelLayout::BPPNone) ? fetch1PixelTable[layout->bpp] : Fetch1PixelFunc(fetch1Pixel<bpp>);
if (canUseFastMatrixPath(cx, cy, length, data)) {
// The increment pr x in the scanline
int fdx = (int)(data->m11 * fixed_scale);
int fdy = (int)(data->m12 * fixed_scale);
int fx = int((data->m21 * cy
+ data->m11 * cx + data->dx) * fixed_scale);
int fy = int((data->m22 * cy
+ data->m12 * cx + data->dy) * fixed_scale);
if (fdy == 0) { // simple scale, no rotation or shear
int py = (fy >> 16);
fetchTransformed_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, py);
const uchar *src = image.scanLine(py);
int i = 0;
if (blendType == BlendTransformed) {
int fastLen = length;
if (fdx > 0)
fastLen = qMin(fastLen, int((qint64(image.x2 - 1) * fixed_scale - fx) / fdx));
else if (fdx < 0)
fastLen = qMin(fastLen, int((qint64(image.x1) * fixed_scale - fx) / fdx));
for (; i < fastLen; ++i) {
int x1 = (fx >> 16);
int x2 = x1;
fetchTransformed_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1);
if (x1 == x2)
break;
if constexpr (useFetch)
buffer[i] = fetch1(src, x1);
else
buffer[i] = reinterpret_cast<const T*>(src)[x1];
fx += fdx;
}
for (; i < fastLen; ++i) {
int px = (fx >> 16);
if constexpr (useFetch)
buffer[i] = fetch1(src, px);
else
buffer[i] = reinterpret_cast<const T*>(src)[px];
fx += fdx;
}
}
for (; i < length; ++i) {
int px = (fx >> 16);
fetchTransformed_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, px);
if constexpr (useFetch)
buffer[i] = fetch1(src, px);
else
buffer[i] = reinterpret_cast<const T*>(src)[px];
fx += fdx;
}
} else { // rotation or shear
int i = 0;
if (blendType == BlendTransformed) {
int fastLen = length;
if (fdx > 0)
fastLen = qMin(fastLen, int((qint64(image.x2 - 1) * fixed_scale - fx) / fdx));
else if (fdx < 0)
fastLen = qMin(fastLen, int((qint64(image.x1) * fixed_scale - fx) / fdx));
if (fdy > 0)
fastLen = qMin(fastLen, int((qint64(image.y2 - 1) * fixed_scale - fy) / fdy));
else if (fdy < 0)
fastLen = qMin(fastLen, int((qint64(image.y1) * fixed_scale - fy) / fdy));
for (; i < fastLen; ++i) {
int x1 = (fx >> 16);
int y1 = (fy >> 16);
int x2 = x1;
int y2 = y1;
fetchTransformed_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1);
fetchTransformed_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1);
if (x1 == x2 && y1 == y2)
break;
if constexpr (useFetch)
buffer[i] = fetch1(image.scanLine(y1), x1);
else
buffer[i] = reinterpret_cast<const T*>(image.scanLine(y1))[x1];
fx += fdx;
fy += fdy;
}
for (; i < fastLen; ++i) {
int px = (fx >> 16);
int py = (fy >> 16);
if constexpr (useFetch)
buffer[i] = fetch1(image.scanLine(py), px);
else
buffer[i] = reinterpret_cast<const T*>(image.scanLine(py))[px];
fx += fdx;
fy += fdy;
}
}
for (; i < length; ++i) {
int px = (fx >> 16);
int py = (fy >> 16);
fetchTransformed_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, px);
fetchTransformed_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, py);
if constexpr (useFetch)
buffer[i] = fetch1(image.scanLine(py), px);
else
buffer[i] = reinterpret_cast<const T*>(image.scanLine(py))[px];
fx += fdx;
fy += fdy;
}
}
} else {
const qreal fdx = data->m11;
const qreal fdy = data->m12;
const qreal fdw = data->m13;
qreal fx = data->m21 * cy + data->m11 * cx + data->dx;
qreal fy = data->m22 * cy + data->m12 * cx + data->dy;
qreal fw = data->m23 * cy + data->m13 * cx + data->m33;
T *const end = buffer + length;
T *b = buffer;
while (b < end) {
const qreal iw = fw == 0 ? 1 : 1 / fw;
const qreal tx = fx * iw;
const qreal ty = fy * iw;
int px = qFloor(tx);
int py = qFloor(ty);
fetchTransformed_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, py);
fetchTransformed_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, px);
if constexpr (useFetch)
*b = fetch1(image.scanLine(py), px);
else
*b = reinterpret_cast<const T*>(image.scanLine(py))[px];
fx += fdx;
fy += fdy;
fw += fdw;
//force increment to avoid /0
if (!fw) {
fw += fdw;
}
++b;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r8d, %ebp
movq %rsi, %rbx
cvtsi2sd %ecx, %xmm2
movq %rdi, %r14
movsd 0x1aae8(%rip), %xmm0 # 0x574c50
cvtsi2sd %edx, %xmm4
addsd %xmm0, %xmm2
addsd %xmm0, %xmm4
testb $0x1, 0x8a(%rsi)
movapd %xmm2, 0x70(%rsp)
movapd %xmm4, 0x60(%rsp)
je 0x55a7ac
movupd 0x38(%rbx), %xmm3
movupd 0x50(%rbx), %xmm0
cvtsi2sd %ebp, %xmm1
movapd %xmm1, 0x50(%rsp)
movupd 0x70(%rbx), %xmm1
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
mulpd %xmm3, %xmm2
unpcklpd %xmm4, %xmm4 # xmm4 = xmm4[0,0]
mulpd %xmm0, %xmm4
addpd %xmm2, %xmm4
addpd %xmm1, %xmm4
movapd 0x3626a(%rip), %xmm1 # 0x590430
mulpd %xmm1, %xmm4
movapd %xmm4, 0x30(%rsp)
movapd %xmm4, %xmm0
unpckhpd %xmm4, %xmm0 # xmm0 = xmm0[1],xmm4[1]
movapd %xmm0, 0x80(%rsp)
minsd %xmm4, %xmm0
movapd %xmm0, 0x40(%rsp)
movapd %xmm3, 0x20(%rsp)
mulpd %xmm3, %xmm1
movapd %xmm1, (%rsp)
movapd %xmm1, %xmm0
callq 0x1409c0
movapd %xmm0, 0x10(%rsp)
movapd (%rsp), %xmm0
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
callq 0x1409c0
movapd 0x50(%rsp), %xmm3
movapd 0x30(%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
unpcklpd %xmm3, %xmm3 # xmm3 = xmm3[0,0]
mulpd %xmm1, %xmm3
addpd %xmm2, %xmm3
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0 # xmm0 = xmm0[1],xmm3[1]
movapd %xmm0, %xmm1
minsd %xmm3, %xmm1
minsd 0x40(%rsp), %xmm1
ucomisd 0x1a949(%rip), %xmm1 # 0x574ba0
jb 0x55a280
movapd 0x80(%rsp), %xmm1
maxsd %xmm2, %xmm1
maxsd %xmm3, %xmm0
maxsd %xmm1, %xmm0
movsd 0x1a932(%rip), %xmm1 # 0x574ba8
ucomisd %xmm0, %xmm1
jae 0x55a3fd
testl %ebp, %ebp
jle 0x55a3eb
movslq %ebp, %rax
movsd 0x48(%rbx), %xmm1
leaq (%r14,%rax,4), %r15
movapd 0x70(%rsp), %xmm3
movapd %xmm3, %xmm0
movsd %xmm1, 0x10(%rsp)
mulsd %xmm1, %xmm0
movsd 0x60(%rbx), %xmm2
movapd 0x60(%rsp), %xmm1
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
addsd 0x68(%rbx), %xmm2
unpcklpd %xmm3, %xmm3 # xmm3 = xmm3[0,0]
mulpd 0x20(%rsp), %xmm3
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
movupd 0x50(%rbx), %xmm0
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
movupd 0x70(%rbx), %xmm3
addpd %xmm0, %xmm3
movq 0xa8(%rbx), %r12
movq 0xc8(%rbx), %r13
xorpd %xmm5, %xmm5
movsd 0x1a462(%rip), %xmm4 # 0x574760
movapd %xmm4, %xmm0
divsd %xmm2, %xmm0
movapd %xmm2, (%rsp)
movapd %xmm2, %xmm1
cmpeqsd %xmm5, %xmm1
movapd %xmm1, %xmm2
andnpd %xmm0, %xmm2
andpd %xmm4, %xmm1
orpd %xmm2, %xmm1
movapd %xmm3, %xmm0
mulsd %xmm1, %xmm0
movapd %xmm3, 0x50(%rsp)
unpckhpd %xmm3, %xmm3 # xmm3 = xmm3[1,1]
mulsd %xmm1, %xmm3
movapd %xmm3, 0x30(%rsp)
callq 0x138490
movsd %xmm0, 0x40(%rsp)
movapd 0x30(%rsp), %xmm0
callq 0x138490
cvttsd2si %xmm0, %ecx
movl 0xc4(%rbx), %eax
decl %eax
cmpl %ecx, %eax
jl 0x55a368
movl %ecx, %eax
movl 0xb8(%rbx), %ecx
movl 0xbc(%rbx), %edx
cmpl %edx, %eax
jg 0x55a37a
movl %edx, %eax
cvttsd2si 0x40(%rsp), %esi
movl 0xc0(%rbx), %edx
decl %edx
cmpl %esi, %edx
movapd (%rsp), %xmm2
movapd 0x50(%rsp), %xmm3
xorpd %xmm5, %xmm5
jl 0x55a39d
movl %esi, %edx
cmpl %ecx, %edx
jg 0x55a3a3
movl %ecx, %edx
cltq
imulq %r13, %rax
addq %r12, %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, (%r14)
addpd 0x20(%rsp), %xmm3
movsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm2
addsd %xmm2, %xmm0
movapd %xmm2, %xmm1
cmpneqsd %xmm5, %xmm1
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm1, %xmm2
addq $0x4, %r14
cmpq %r15, %r14
jb 0x55a2f6
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cvttpd2dq (%rsp), %xmm1
pshufd $0x55, %xmm1, %xmm0 # xmm0 = xmm1[1,1,1,1]
movd %xmm0, %esi
cvttpd2dq %xmm2, %xmm0
testl %esi, %esi
je 0x55a44b
movd %xmm1, %edi
testl %edi, %edi
jle 0x55a4b9
movslq 0xc0(%rbx), %rax
shlq $0x10, %rax
movd %xmm0, %ecx
movslq %ecx, %rcx
subq %rcx, %rax
addq $-0x10000, %rax # imm = 0xFFFF0000
movl %edi, %ecx
cqto
idivq %rcx
movq %rax, %rcx
cmpl %ebp, %ecx
cmovgel %ebp, %ecx
jmp 0x55a4c1
pshufd $0x55, %xmm0, %xmm2 # xmm2 = xmm0[1,1,1,1]
movd %xmm2, %eax
sarl $0x10, %eax
movl 0xc4(%rbx), %ecx
decl %ecx
cmpl %eax, %ecx
cmovgel %eax, %ecx
movl 0xbc(%rbx), %eax
cmpl %eax, %ecx
cmovlel %eax, %ecx
movslq %ecx, %rcx
imulq 0xc8(%rbx), %rcx
addq 0xa8(%rbx), %rcx
movd %xmm1, %esi
testl %esi, %esi
jle 0x55a6a8
movslq 0xc0(%rbx), %rax
shlq $0x10, %rax
movd %xmm0, %edx
movslq %edx, %rdx
subq %rdx, %rax
addq $-0x10000, %rax # imm = 0xFFFF0000
movl %esi, %edi
cqto
idivq %rdi
cmpl %ebp, %eax
cmovgel %ebp, %eax
jmp 0x55a6b0
movl %ebp, %ecx
js 0x55a772
testl %esi, %esi
jle 0x55a4ea
movslq 0xc4(%rbx), %rax
shlq $0x10, %rax
pshufd $0x55, %xmm0, %xmm2 # xmm2 = xmm0[1,1,1,1]
movd %xmm2, %edx
movslq %edx, %rdx
subq %rdx, %rax
addq $-0x10000, %rax # imm = 0xFFFF0000
movl %esi, %r8d
jmp 0x55a507
movslq 0xbc(%rbx), %rax
shlq $0x10, %rax
pshufd $0x55, %xmm0, %xmm2 # xmm2 = xmm0[1,1,1,1]
movd %xmm2, %edx
movslq %edx, %rdx
subq %rdx, %rax
movslq %esi, %r8
cqto
idivq %r8
cmpl %eax, %ecx
cmovll %ecx, %eax
testl %eax, %eax
jle 0x55a5b8
movl %eax, %edx
xorl %ecx, %ecx
pcmpeqd %xmm2, %xmm2
movdqa %xmm0, %xmm4
psrad $0x10, %xmm4
movq 0xb8(%rbx), %xmm5
movq 0xc0(%rbx), %xmm3
paddd %xmm2, %xmm3
movdqa %xmm4, %xmm6
pcmpgtd %xmm3, %xmm6
pand %xmm6, %xmm3
pandn %xmm4, %xmm6
por %xmm3, %xmm6
movdqa %xmm6, %xmm3
pcmpgtd %xmm5, %xmm3
pand %xmm3, %xmm6
pandn %xmm5, %xmm3
por %xmm6, %xmm3
pcmpeqd %xmm3, %xmm4
pshufd $0x50, %xmm4, %xmm4 # xmm4 = xmm4[0,0,1,1]
movmskpd %xmm4, %r8d
cmpl $0x3, %r8d
je 0x55a5ba
pshufd $0x55, %xmm3, %xmm4 # xmm4 = xmm3[1,1,1,1]
movd %xmm4, %r8d
movslq %r8d, %r8
imulq 0xc8(%rbx), %r8
addq 0xa8(%rbx), %r8
movd %xmm3, %r9d
movslq %r9d, %r9
movl (%r8,%r9,4), %r8d
movl %r8d, (%r14,%rcx,4)
paddd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rdx
jne 0x55a521
jmp 0x55a607
xorl %ecx, %ecx
cmpl %eax, %ecx
jge 0x55a605
movq 0xa8(%rbx), %rdx
movq 0xc8(%rbx), %r8
movl %ecx, %ecx
movd %xmm0, %r9d
sarl $0x10, %r9d
pshufd $0x55, %xmm0, %xmm2 # xmm2 = xmm0[1,1,1,1]
movd %xmm2, %r10d
sarl $0x10, %r10d
movslq %r10d, %r10
imulq %r8, %r10
addq %rdx, %r10
movslq %r9d, %r9
movl (%r10,%r9,4), %r9d
movl %r9d, (%r14,%rcx,4)
paddd %xmm1, %xmm0
incq %rcx
cmpl %ecx, %eax
jg 0x55a5ce
movl %ecx, %eax
cmpl %ebp, %eax
jge 0x55a3eb
movq 0xa8(%rbx), %rcx
movq 0xc8(%rbx), %rdx
movl %eax, %r10d
movd %xmm0, %r8d
pshufd $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %r9d
leaq (%r14,%r10,4), %r10
movl %r8d, %r11d
sarl $0x10, %r11d
movl %r9d, %r14d
sarl $0x10, %r14d
movl 0xc0(%rbx), %r15d
decl %r15d
cmpl %r11d, %r15d
cmovgel %r11d, %r15d
movl 0xb8(%rbx), %r11d
cmpl %r11d, %r15d
cmovlel %r11d, %r15d
movl 0xc4(%rbx), %r11d
decl %r11d
cmpl %r14d, %r11d
cmovgel %r14d, %r11d
movl 0xbc(%rbx), %r14d
cmpl %r14d, %r11d
cmovlel %r14d, %r11d
movslq %r11d, %r11
imulq %rdx, %r11
addq %rcx, %r11
movslq %r15d, %r14
movl (%r11,%r14,4), %r11d
movl %r11d, (%r10)
addl %edi, %r8d
addl %esi, %r9d
addq $0x4, %r10
incl %eax
cmpl %ebp, %eax
jl 0x55a633
jmp 0x55a3eb
movl %ebp, %eax
js 0x55a78f
movl %eax, %edi
movd %xmm0, %edx
testl %eax, %eax
jle 0x55a700
xorl %eax, %eax
movl %edx, %r9d
sarl $0x10, %r9d
movl 0xb8(%rbx), %r10d
movl 0xc0(%rbx), %r8d
decl %r8d
cmpl %r9d, %r8d
cmovgel %r9d, %r8d
cmpl %r10d, %r8d
cmovlel %r10d, %r8d
cmpl %r9d, %r8d
je 0x55a702
movslq %r8d, %r8
movl (%rcx,%r8,4), %r8d
movl %r8d, (%r14,%rax,4)
addl %esi, %edx
incq %rax
cmpq %rax, %rdi
jne 0x55a6bc
movl %edi, %eax
jmp 0x55a723
xorl %eax, %eax
cmpl %edi, %eax
jge 0x55a723
movl %eax, %eax
movl %edx, %r8d
sarl $0x10, %r8d
movslq %r8d, %r8
movl (%rcx,%r8,4), %r8d
movl %r8d, (%r14,%rax,4)
addl %esi, %edx
incq %rax
cmpl %eax, %edi
jg 0x55a708
cmpl %ebp, %eax
jge 0x55a3eb
movl %eax, %edi
leaq (%r14,%rdi,4), %rdi
movl %edx, %r8d
sarl $0x10, %r8d
movl 0xc0(%rbx), %r9d
decl %r9d
cmpl %r8d, %r9d
cmovgel %r8d, %r9d
movl 0xb8(%rbx), %r8d
cmpl %r8d, %r9d
cmovlel %r8d, %r9d
movslq %r9d, %r8
movl (%rcx,%r8,4), %r8d
movl %r8d, (%rdi)
addl %esi, %edx
addq $0x4, %rdi
incl %eax
cmpl %ebp, %eax
jl 0x55a731
jmp 0x55a3eb
movslq 0xb8(%rbx), %rax
shlq $0x10, %rax
movd %xmm0, %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movslq %edi, %rcx
jmp 0x55a43c
movslq 0xb8(%rbx), %rax
shlq $0x10, %rax
movd %xmm0, %edx
movslq %edx, %rdx
subq %rdx, %rax
movslq %esi, %rdi
jmp 0x55a4aa
movupd 0x38(%rbx), %xmm0
movapd %xmm0, 0x20(%rsp)
jmp 0x55a280
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinearARGB32PM_fast_rotate_helper<(TextureBlendType)4>(unsigned int*, unsigned int*, QTextureData const&, int&, int&, int, int) | static void QT_FASTCALL fetchTransformedBilinearARGB32PM_fast_rotate_helper(uint *b, uint *end, const QTextureData &image,
int &fx, int &fy, int fdx, int fdy)
{
//we are zooming less than 8x, use 4bit precision
if (blendType != BlendTransformedBilinearTiled) {
const qint64 min_fx = qint64(image.x1) * fixed_scale;
const qint64 max_fx = qint64(image.x2 - 1) * fixed_scale;
const qint64 min_fy = qint64(image.y1) * fixed_scale;
const qint64 max_fy = qint64(image.y2 - 1) * fixed_scale;
// first handle the possibly bounded part in the beginning
while (b < end) {
int x1 = (fx >> 16);
int x2;
int y1 = (fy >> 16);
int y2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
if (x1 != x2 && y1 != y2)
break;
const uint *s1 = (const uint *)image.scanLine(y1);
const uint *s2 = (const uint *)image.scanLine(y2);
uint tl = s1[x1];
uint tr = s1[x2];
uint bl = s2[x1];
uint br = s2[x2];
if (hasFastInterpolate4()) {
int distx = (fx & 0x0000ffff) >> 8;
int disty = (fy & 0x0000ffff) >> 8;
*b = interpolate_4_pixels(tl, tr, bl, br, distx, disty);
} else {
int distx = ((fx & 0x0000ffff) + 0x0800) >> 12;
int disty = ((fy & 0x0000ffff) + 0x0800) >> 12;
*b = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty);
}
fx += fdx;
fy += fdy;
++b;
}
uint *boundedEnd = end;
if (fdx > 0)
boundedEnd = qMin(boundedEnd, b + (max_fx - fx) / fdx);
else if (fdx < 0)
boundedEnd = qMin(boundedEnd, b + (min_fx - fx) / fdx);
if (fdy > 0)
boundedEnd = qMin(boundedEnd, b + (max_fy - fy) / fdy);
else if (fdy < 0)
boundedEnd = qMin(boundedEnd, b + (min_fy - fy) / fdy);
// until boundedEnd we can now have a fast middle part without boundary checks
#if defined(__SSE2__)
const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
const __m128i v_256 = _mm_set1_epi16(256);
const __m128i v_fdx = _mm_set1_epi32(fdx*4);
const __m128i v_fdy = _mm_set1_epi32(fdy*4);
const __m128i v_fxy_r = _mm_set1_epi32(0x8);
__m128i v_fx = _mm_setr_epi32(fx, fx + fdx, fx + fdx + fdx, fx + fdx + fdx + fdx);
__m128i v_fy = _mm_setr_epi32(fy, fy + fdy, fy + fdy + fdy, fy + fdy + fdy + fdy);
const uchar *textureData = image.imageData;
const qsizetype bytesPerLine = image.bytesPerLine;
const __m128i vbpl = _mm_shufflelo_epi16(_mm_cvtsi32_si128(bytesPerLine/4), _MM_SHUFFLE(0, 0, 0, 0));
while (b < boundedEnd - 3) {
const __m128i vy = _mm_packs_epi32(_mm_srli_epi32(v_fy, 16), _mm_setzero_si128());
// 4x16bit * 4x16bit -> 4x32bit
__m128i offset = _mm_unpacklo_epi16(_mm_mullo_epi16(vy, vbpl), _mm_mulhi_epi16(vy, vbpl));
offset = _mm_add_epi32(offset, _mm_srli_epi32(v_fx, 16));
const int offset0 = _mm_cvtsi128_si32(offset); offset = _mm_srli_si128(offset, 4);
const int offset1 = _mm_cvtsi128_si32(offset); offset = _mm_srli_si128(offset, 4);
const int offset2 = _mm_cvtsi128_si32(offset); offset = _mm_srli_si128(offset, 4);
const int offset3 = _mm_cvtsi128_si32(offset);
const uint *topData = (const uint *)(textureData);
const __m128i tl = _mm_setr_epi32(topData[offset0], topData[offset1], topData[offset2], topData[offset3]);
const __m128i tr = _mm_setr_epi32(topData[offset0 + 1], topData[offset1 + 1], topData[offset2 + 1], topData[offset3 + 1]);
const uint *bottomData = (const uint *)(textureData + bytesPerLine);
const __m128i bl = _mm_setr_epi32(bottomData[offset0], bottomData[offset1], bottomData[offset2], bottomData[offset3]);
const __m128i br = _mm_setr_epi32(bottomData[offset0 + 1], bottomData[offset1 + 1], bottomData[offset2 + 1], bottomData[offset3 + 1]);
__m128i v_distx = _mm_srli_epi16(v_fx, 8);
__m128i v_disty = _mm_srli_epi16(v_fy, 8);
v_distx = _mm_srli_epi16(_mm_add_epi32(v_distx, v_fxy_r), 4);
v_disty = _mm_srli_epi16(_mm_add_epi32(v_disty, v_fxy_r), 4);
v_distx = _mm_shufflehi_epi16(v_distx, _MM_SHUFFLE(2,2,0,0));
v_distx = _mm_shufflelo_epi16(v_distx, _MM_SHUFFLE(2,2,0,0));
v_disty = _mm_shufflehi_epi16(v_disty, _MM_SHUFFLE(2,2,0,0));
v_disty = _mm_shufflelo_epi16(v_disty, _MM_SHUFFLE(2,2,0,0));
interpolate_4_pixels_16_sse2(tl, tr, bl, br, v_distx, v_disty, colorMask, v_256, b);
b += 4;
v_fx = _mm_add_epi32(v_fx, v_fdx);
v_fy = _mm_add_epi32(v_fy, v_fdy);
}
fx = _mm_cvtsi128_si32(v_fx);
fy = _mm_cvtsi128_si32(v_fy);
#elif defined(__ARM_NEON__)
const int16x8_t colorMask = vdupq_n_s16(0x00ff);
const int16x8_t invColorMask = vmvnq_s16(colorMask);
const int16x8_t v_256 = vdupq_n_s16(256);
int32x4_t v_fdx = vdupq_n_s32(fdx * 4);
int32x4_t v_fdy = vdupq_n_s32(fdy * 4);
const uchar *textureData = image.imageData;
const qsizetype bytesPerLine = image.bytesPerLine;
int32x4_t v_fx = vmovq_n_s32(fx);
int32x4_t v_fy = vmovq_n_s32(fy);
v_fx = vsetq_lane_s32(fx + fdx, v_fx, 1);
v_fy = vsetq_lane_s32(fy + fdy, v_fy, 1);
v_fx = vsetq_lane_s32(fx + fdx * 2, v_fx, 2);
v_fy = vsetq_lane_s32(fy + fdy * 2, v_fy, 2);
v_fx = vsetq_lane_s32(fx + fdx * 3, v_fx, 3);
v_fy = vsetq_lane_s32(fy + fdy * 3, v_fy, 3);
const int32x4_t v_ffff_mask = vdupq_n_s32(0x0000ffff);
const int32x4_t v_round = vdupq_n_s32(0x0800);
// Pre-initialize to work-around code-analysis warnings/crashes in MSVC:
uint32x4x2_t v_top = {};
uint32x4x2_t v_bot = {};
while (b < boundedEnd - 3) {
int x1 = (fx >> 16);
int y1 = (fy >> 16);
fx += fdx; fy += fdy;
const uchar *sl = textureData + bytesPerLine * y1;
const uint *s1 = reinterpret_cast<const uint *>(sl);
const uint *s2 = reinterpret_cast<const uint *>(sl + bytesPerLine);
v_top = vld2q_lane_u32(s1 + x1, v_top, 0);
v_bot = vld2q_lane_u32(s2 + x1, v_bot, 0);
x1 = (fx >> 16);
y1 = (fy >> 16);
fx += fdx; fy += fdy;
sl = textureData + bytesPerLine * y1;
s1 = reinterpret_cast<const uint *>(sl);
s2 = reinterpret_cast<const uint *>(sl + bytesPerLine);
v_top = vld2q_lane_u32(s1 + x1, v_top, 1);
v_bot = vld2q_lane_u32(s2 + x1, v_bot, 1);
x1 = (fx >> 16);
y1 = (fy >> 16);
fx += fdx; fy += fdy;
sl = textureData + bytesPerLine * y1;
s1 = reinterpret_cast<const uint *>(sl);
s2 = reinterpret_cast<const uint *>(sl + bytesPerLine);
v_top = vld2q_lane_u32(s1 + x1, v_top, 2);
v_bot = vld2q_lane_u32(s2 + x1, v_bot, 2);
x1 = (fx >> 16);
y1 = (fy >> 16);
fx += fdx; fy += fdy;
sl = textureData + bytesPerLine * y1;
s1 = reinterpret_cast<const uint *>(sl);
s2 = reinterpret_cast<const uint *>(sl + bytesPerLine);
v_top = vld2q_lane_u32(s1 + x1, v_top, 3);
v_bot = vld2q_lane_u32(s2 + x1, v_bot, 3);
int32x4_t v_distx = vshrq_n_s32(vaddq_s32(vandq_s32(v_fx, v_ffff_mask), v_round), 12);
int32x4_t v_disty = vshrq_n_s32(vaddq_s32(vandq_s32(v_fy, v_ffff_mask), v_round), 12);
v_distx = vorrq_s32(v_distx, vshlq_n_s32(v_distx, 16));
v_disty = vorrq_s32(v_disty, vshlq_n_s32(v_disty, 16));
int16x8_t v_disty_ = vshlq_n_s16(vreinterpretq_s16_s32(v_disty), 4);
interpolate_4_pixels_16_neon(
vreinterpretq_s16_u32(v_top.val[0]), vreinterpretq_s16_u32(v_top.val[1]),
vreinterpretq_s16_u32(v_bot.val[0]), vreinterpretq_s16_u32(v_bot.val[1]),
vreinterpretq_s16_s32(v_distx), vreinterpretq_s16_s32(v_disty),
v_disty_, colorMask, invColorMask, v_256, b);
b += 4;
v_fx = vaddq_s32(v_fx, v_fdx);
v_fy = vaddq_s32(v_fy, v_fdy);
}
#elif defined(__loongarch_sx)
const __m128i v_fdx = __lsx_vreplgr2vr_w(fdx*4);
const __m128i v_fdy = __lsx_vreplgr2vr_w(fdy*4);
const __m128i v_fxy_r = __lsx_vreplgr2vr_w(0x8);
__m128i v_fx = (__m128i)(v4i32){fx, fx + fdx, fx + fdx + fdx, fx + fdx + fdx + fdx};
__m128i v_fy = (__m128i)(v4i32){fy, fy + fdy, fy + fdy + fdy, fy + fdy + fdy + fdy};
const uchar *textureData = image.imageData;
const qsizetype bytesPerLine = image.bytesPerLine;
const __m128i zero = __lsx_vldi(0);
const __m128i shuffleMask = (__m128i)(v8i16){0, 0, 0, 0, 4, 5, 6, 7};
const __m128i shuffleMask1 = (__m128i)(v8i16){0, 0, 2, 2, 4, 4, 6, 6};
const __m128i vbpl = __lsx_vshuf_h(shuffleMask, zero, __lsx_vinsgr2vr_w(zero, bytesPerLine/4, 0));
while (b < boundedEnd - 3) {
const __m128i vy = __lsx_vpickev_h(zero, __lsx_vsat_w(__lsx_vsrli_w(v_fy, 16), 15));
// 4x16bit * 4x16bit -> 4x32bit
__m128i offset = __lsx_vilvl_h(__lsx_vmuh_h(vy, vbpl), __lsx_vmul_h(vy, vbpl));
offset = __lsx_vadd_w(offset, __lsx_vsrli_w(v_fx, 16));
const int offset0 = __lsx_vpickve2gr_w(offset, 0);
const int offset1 = __lsx_vpickve2gr_w(offset, 1);
const int offset2 = __lsx_vpickve2gr_w(offset, 2);
const int offset3 = __lsx_vpickve2gr_w(offset, 3);
const uint *topData = (const uint *)(textureData);
const __m128i tl = (__m128i)(v4u32){topData[offset0], topData[offset1], topData[offset2], topData[offset3]};
const __m128i tr = (__m128i)(v4u32){topData[offset0 + 1], topData[offset1 + 1], topData[offset2 + 1], topData[offset3 + 1]};
const uint *bottomData = (const uint *)(textureData + bytesPerLine);
const __m128i bl = (__m128i)(v4u32){bottomData[offset0], bottomData[offset1], bottomData[offset2], bottomData[offset3]};
const __m128i br = (__m128i)(v4u32){bottomData[offset0 + 1], bottomData[offset1 + 1], bottomData[offset2 + 1], bottomData[offset3 + 1]};
__m128i v_distx = __lsx_vsrli_h(v_fx, 8);
__m128i v_disty = __lsx_vsrli_h(v_fy, 8);
v_distx = __lsx_vsrli_h(__lsx_vadd_w(v_distx, v_fxy_r), 4);
v_disty = __lsx_vsrli_h(__lsx_vadd_w(v_disty, v_fxy_r), 4);
v_distx = __lsx_vshuf_h(shuffleMask1, zero, v_distx);
v_disty = __lsx_vshuf_h(shuffleMask1, zero, v_disty);
interpolate_4_pixels_16_lsx(tl, tr, bl, br, v_distx, v_disty, b);
b += 4;
v_fx = __lsx_vadd_w(v_fx, v_fdx);
v_fy = __lsx_vadd_w(v_fy, v_fdy);
}
fx = __lsx_vpickve2gr_w(v_fx, 0);
fy = __lsx_vpickve2gr_w(v_fy, 0);
#endif
while (b < boundedEnd) {
int x = (fx >> 16);
int y = (fy >> 16);
const uint *s1 = (const uint *)image.scanLine(y);
const uint *s2 = (const uint *)image.scanLine(y + 1);
if (hasFastInterpolate4()) {
int distx = (fx & 0x0000ffff) >> 8;
int disty = (fy & 0x0000ffff) >> 8;
*b = interpolate_4_pixels(s1 + x, s2 + x, distx, disty);
} else {
int distx = ((fx & 0x0000ffff) + 0x0800) >> 12;
int disty = ((fy & 0x0000ffff) + 0x0800) >> 12;
*b = interpolate_4_pixels_16(s1[x], s1[x + 1], s2[x], s2[x + 1], distx, disty);
}
fx += fdx;
fy += fdy;
++b;
}
}
while (b < end) {
int x1 = (fx >> 16);
int x2;
int y1 = (fy >> 16);
int y2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
const uint *s1 = (const uint *)image.scanLine(y1);
const uint *s2 = (const uint *)image.scanLine(y2);
uint tl = s1[x1];
uint tr = s1[x2];
uint bl = s2[x1];
uint br = s2[x2];
if (hasFastInterpolate4()) {
int distx = (fx & 0x0000ffff) >> 8;
int disty = (fy & 0x0000ffff) >> 8;
*b = interpolate_4_pixels(tl, tr, bl, br, distx, disty);
} else {
int distx = ((fx & 0x0000ffff) + 0x0800) >> 12;
int disty = ((fy & 0x0000ffff) + 0x0800) >> 12;
*b = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty);
}
fx += fdx;
fy += fdy;
++b;
}
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r10
movslq 0x10(%rdx), %rax
movq %rax, -0x10(%rsp)
movslq 0x18(%rdx), %rax
movq %rax, -0x20(%rsp)
movslq 0x14(%rdx), %rax
movq %rax, -0x8(%rsp)
movslq 0x1c(%rdx), %rax
movq %rax, -0x18(%rsp)
cmpq %rsi, %rdi
movq %rsi, -0x28(%rsp)
jae 0x55b5bf
movq (%r10), %r15
movq 0x20(%r10), %r12
movl (%r8), %r13d
pxor %xmm0, %xmm0
movl (%rcx), %ebx
movl %ebx, %eax
sarl $0x10, %eax
movl %r13d, %r14d
sarl $0x10, %r14d
movl 0x18(%r10), %edx
decl %edx
leal 0x1(%rax), %r11d
cmpl %edx, %eax
cmovgel %edx, %r11d
cmovll %eax, %edx
movl 0x10(%r10), %ebp
cmpl %ebp, %eax
cmovll %ebp, %edx
cmovll %ebp, %r11d
movl 0x1c(%r10), %eax
decl %eax
leal 0x1(%r14), %ebp
cmpl %eax, %r14d
cmovgel %eax, %ebp
cmovll %r14d, %eax
movl 0x14(%r10), %esi
cmpl %esi, %r14d
cmovll %esi, %eax
cmovll %esi, %ebp
cmpl %r11d, %edx
je 0x55b4d4
cmpl %ebp, %eax
jne 0x55b5ba
cltq
imulq %r12, %rax
addq %r15, %rax
movslq %ebp, %rsi
imulq %r12, %rsi
addq %r15, %rsi
movslq %edx, %rdx
movslq %r11d, %r11
shrl $0x8, %ebx
movl $0xff, %ebp
andl %ebp, %ebx
movd (%rax,%r11,4), %xmm1
movd (%rax,%rdx,4), %xmm2
punpckldq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movd (%rsi,%r11,4), %xmm1
movd (%rsi,%rdx,4), %xmm3
punpckldq %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
punpcklbw %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3],xmm2[4],xmm0[4],xmm2[5],xmm0[5],xmm2[6],xmm0[6],xmm2[7],xmm0[7]
punpcklbw %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3],xmm3[4],xmm0[4],xmm3[5],xmm0[5],xmm3[6],xmm0[6],xmm3[7],xmm0[7]
shrl $0x8, %r13d
andl %ebp, %r13d
movl $0x100, %eax # imm = 0x100
subl %r13d, %eax
movd %eax, %xmm1
pshuflw $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
pmullw %xmm2, %xmm1
movd %r13d, %xmm2
pshuflw $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
pmullw %xmm3, %xmm2
paddw %xmm1, %xmm2
movl $0x100, %eax # imm = 0x100
subl %ebx, %eax
movd %eax, %xmm1
movd %ebx, %xmm3
punpcklwd %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1],xmm1[2],xmm3[2],xmm1[3],xmm3[3]
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
pshufd $0xd8, %xmm2, %xmm2 # xmm2 = xmm2[0,2,1,3]
pshuflw $0xd8, %xmm2, %xmm2 # xmm2 = xmm2[0,2,1,3,4,5,6,7]
pshufhw $0xd8, %xmm2, %xmm2 # xmm2 = xmm2[0,1,2,3,4,6,5,7]
psrlw $0x8, %xmm2
pmaddwd %xmm1, %xmm2
psrld $0x8, %xmm2
packssdw %xmm2, %xmm2
packuswb %xmm2, %xmm2
movd %xmm2, (%rdi)
addl %r9d, (%rcx)
movl (%r8), %r13d
movl 0x38(%rsp), %eax
addl %eax, %r13d
movl %r13d, (%r8)
addq $0x4, %rdi
movq -0x28(%rsp), %rsi
cmpq %rsi, %rdi
jb 0x55b478
jmp 0x55b5bf
movq -0x28(%rsp), %rsi
movq $-0x10000, %rbx # imm = 0xFFFF0000
movq -0x10(%rsp), %rax
shlq $0x10, %rax
testl %r9d, %r9d
jle 0x55b600
movq -0x20(%rsp), %rax
shlq $0x10, %rax
addq %rbx, %rax
movslq (%rcx), %rdx
subq %rdx, %rax
movl %r9d, %r11d
cqto
idivq %r11
leaq (%rdi,%rax,4), %r15
cmpq %rsi, %r15
cmovaq %rsi, %r15
movl 0x38(%rsp), %r14d
jmp 0x55b623
movq %rsi, %r15
movl 0x38(%rsp), %r14d
jns 0x55b623
movslq (%rcx), %rdx
subq %rdx, %rax
movslq %r9d, %r11
cqto
idivq %r11
leaq (%rdi,%rax,4), %r15
cmpq %rsi, %r15
cmovaq %rsi, %r15
movq -0x8(%rsp), %rax
shlq $0x10, %rax
testl %r14d, %r14d
jle 0x55b658
movq -0x18(%rsp), %rax
shlq $0x10, %rax
addq %rbx, %rax
movslq (%r8), %rbx
subq %rbx, %rax
movl %r14d, %esi
cqto
idivq %rsi
leaq (%rdi,%rax,4), %rax
cmpq %rax, %r15
cmovaeq %rax, %r15
jmp 0x55b661
movl (%r8), %ebx
js 0x55bb7d
movl (%rcx), %eax
leal (%rax,%r9), %edx
leal (%rdx,%r9), %esi
movd %esi, %xmm1
addl %r9d, %esi
movd %esi, %xmm0
punpckldq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd %edx, %xmm2
movd %eax, %xmm0
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
punpcklqdq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
leal (%rbx,%r14), %eax
leal (%rax,%r14), %edx
movd %edx, %xmm2
addl %r14d, %edx
movd %edx, %xmm1
punpckldq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movd %eax, %xmm3
movd %ebx, %xmm1
punpckldq %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
punpcklqdq %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
movq 0x20(%r10), %rax
leaq 0x3(%rax), %rbx
testq %rax, %rax
cmovnsq %rax, %rbx
leaq -0xc(%r15), %rdx
cmpq %rdx, %rdi
jae 0x55b92c
movd %r9d, %xmm2
pshufd $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
pslld $0x2, %xmm2
movd %r14d, %xmm3
pshufd $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
pslld $0x2, %xmm3
movq (%r10), %r11
shrq $0x2, %rbx
movd %ebx, %xmm4
pshuflw $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0,4,5,6,7]
addq %r11, %rax
movdqa 0x72b9a(%rip), %xmm6 # 0x5ce2a0
movdqa 0x62e31(%rip), %xmm8 # 0x5be540
movdqa %xmm1, %xmm5
psrld $0x10, %xmm5
packssdw 0x1a1f0(%rip), %xmm5 # 0x575910
movdqa %xmm5, %xmm7
pmullw %xmm4, %xmm7
pmulhw %xmm4, %xmm5
punpcklwd %xmm5, %xmm7 # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1],xmm7[2],xmm5[2],xmm7[3],xmm5[3]
movdqa %xmm0, %xmm5
psrld $0x10, %xmm5
paddd %xmm7, %xmm5
movd %xmm5, %esi
pshufd $0x55, %xmm5, %xmm7 # xmm7 = xmm5[1,1,1,1]
movd %xmm7, %ebp
pshufd $0xee, %xmm5, %xmm7 # xmm7 = xmm5[2,3,2,3]
movd %xmm7, %r14d
pshufd $0xff, %xmm5, %xmm5 # xmm5 = xmm5[3,3,3,3]
movd %xmm5, %r13d
movslq %esi, %rbx
movslq %ebp, %r12
movslq %r14d, %r14
movslq %r13d, %r13
movd (%r11,%r13,4), %xmm5
movd (%r11,%r14,4), %xmm7
punpckldq %xmm5, %xmm7 # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1]
movd (%r11,%rbx,4), %xmm11
movd (%r11,%r12,4), %xmm5
punpckldq %xmm5, %xmm11 # xmm11 = xmm11[0],xmm5[0],xmm11[1],xmm5[1]
punpcklqdq %xmm7, %xmm11 # xmm11 = xmm11[0],xmm7[0]
movd 0x4(%r11,%r13,4), %xmm5
movd 0x4(%r11,%r14,4), %xmm7
punpckldq %xmm5, %xmm7 # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1]
movd 0x4(%r11,%rbx,4), %xmm10
movd 0x4(%r11,%r12,4), %xmm5
punpckldq %xmm5, %xmm10 # xmm10 = xmm10[0],xmm5[0],xmm10[1],xmm5[1]
punpcklqdq %xmm7, %xmm10 # xmm10 = xmm10[0],xmm7[0]
movd (%rax,%r13,4), %xmm5
movd (%rax,%r14,4), %xmm7
punpckldq %xmm5, %xmm7 # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1]
movd (%rax,%rbx,4), %xmm12
movd (%rax,%r12,4), %xmm5
punpckldq %xmm5, %xmm12 # xmm12 = xmm12[0],xmm5[0],xmm12[1],xmm5[1]
punpcklqdq %xmm7, %xmm12 # xmm12 = xmm12[0],xmm7[0]
movd 0x4(%rax,%r13,4), %xmm5
movd 0x4(%rax,%r14,4), %xmm7
punpckldq %xmm5, %xmm7 # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1]
movd 0x4(%rax,%rbx,4), %xmm13
movd 0x4(%rax,%r12,4), %xmm5
punpckldq %xmm5, %xmm13 # xmm13 = xmm13[0],xmm5[0],xmm13[1],xmm5[1]
punpcklqdq %xmm7, %xmm13 # xmm13 = xmm13[0],xmm7[0]
movdqa %xmm0, %xmm5
psrlw $0x8, %xmm5
movdqa %xmm1, %xmm7
psrlw $0x8, %xmm7
paddd %xmm6, %xmm5
paddd %xmm6, %xmm7
pshuflw $0xa0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,2,2,4,5,6,7]
pshufhw $0xa0, %xmm5, %xmm15 # xmm15 = xmm5[0,1,2,3,4,4,6,6]
psrlw $0x4, %xmm15
pshuflw $0xa0, %xmm7, %xmm5 # xmm5 = xmm7[0,0,2,2,4,5,6,7]
pshufhw $0xa0, %xmm5, %xmm14 # xmm14 = xmm5[0,1,2,3,4,4,6,6]
psrlw $0x4, %xmm14
movdqa %xmm15, %xmm7
pmullw %xmm14, %xmm7
psllw $0x4, %xmm15
psllw $0x4, %xmm14
movdqa %xmm14, %xmm9
paddw %xmm15, %xmm9
psubw %xmm7, %xmm15
psubw %xmm7, %xmm14
movdqa %xmm13, %xmm5
psrlw $0x8, %xmm5
pmullw %xmm7, %xmm5
pand %xmm8, %xmm13
pmullw %xmm7, %xmm13
psubw %xmm9, %xmm7
paddw 0x72a1b(%rip), %xmm7 # 0x5ce2b0
movdqa %xmm11, %xmm9
psrlw $0x8, %xmm9
pmullw %xmm7, %xmm9
pand %xmm8, %xmm11
pmullw %xmm7, %xmm11
movdqa %xmm10, %xmm7
psrlw $0x8, %xmm7
pmullw %xmm15, %xmm7
paddw %xmm9, %xmm7
pand %xmm8, %xmm10
pmullw %xmm15, %xmm10
paddw %xmm11, %xmm10
movdqa %xmm12, %xmm9
psrlw $0x8, %xmm9
pmullw %xmm14, %xmm9
pand %xmm8, %xmm12
pmullw %xmm14, %xmm12
paddw %xmm9, %xmm5
paddw %xmm7, %xmm5
paddw %xmm12, %xmm13
paddw %xmm10, %xmm13
pand 0x62c49(%rip), %xmm5 # 0x5be550
psrlw $0x8, %xmm13
por %xmm5, %xmm13
movdqu %xmm13, (%rdi)
addq $0x10, %rdi
paddd %xmm2, %xmm0
paddd %xmm3, %xmm1
cmpq %rdx, %rdi
jb 0x55b70f
movd %xmm0, (%rcx)
movd %xmm1, %eax
movd %xmm1, (%r8)
cmpq %r15, %rdi
jae 0x55ba29
movq (%r10), %rdx
movq 0x20(%r10), %r11
movl $0xff, %ebx
pxor %xmm0, %xmm0
movl 0x38(%rsp), %r13d
movl (%rcx), %ebp
movl %ebp, %esi
sarl $0x10, %esi
movl %eax, %r14d
sarl $0x10, %r14d
movslq %r14d, %r14
movq %r11, %r12
imulq %r14, %r12
addq %rdx, %r12
incl %r14d
movslq %r14d, %r14
imulq %r11, %r14
addq %rdx, %r14
shrl $0x8, %ebp
andl %ebx, %ebp
movslq %esi, %rsi
movq (%r12,%rsi,4), %xmm1
movq (%r14,%rsi,4), %xmm2
punpcklbw %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
punpcklbw %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3],xmm2[4],xmm0[4],xmm2[5],xmm0[5],xmm2[6],xmm0[6],xmm2[7],xmm0[7]
shrl $0x8, %eax
andl %ebx, %eax
movl $0x100, %esi # imm = 0x100
subl %eax, %esi
movd %esi, %xmm3
pshuflw $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
pmullw %xmm1, %xmm3
movd %eax, %xmm1
pshuflw $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
pmullw %xmm2, %xmm1
paddw %xmm3, %xmm1
movl $0x100, %eax # imm = 0x100
subl %ebp, %eax
movd %eax, %xmm2
movd %ebp, %xmm3
punpcklwd %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1],xmm2[2],xmm3[2],xmm2[3],xmm3[3]
pshufd $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
pshufd $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,2,1,3]
pshuflw $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,2,1,3,4,5,6,7]
pshufhw $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,1,2,3,4,6,5,7]
psrlw $0x8, %xmm1
pmaddwd %xmm2, %xmm1
psrld $0x8, %xmm1
packssdw %xmm1, %xmm1
packuswb %xmm1, %xmm1
movd %xmm1, (%rdi)
addl %r9d, (%rcx)
movl (%r8), %eax
addl %r13d, %eax
movl %eax, (%r8)
addq $0x4, %rdi
cmpq %r15, %rdi
jb 0x55b957
cmpq -0x28(%rsp), %rdi
jae 0x55bb72
movq (%r10), %rdx
movq 0x20(%r10), %r11
pxor %xmm0, %xmm0
movl (%rcx), %ebp
movl %ebp, %esi
sarl $0x10, %esi
movl %eax, %r14d
sarl $0x10, %r14d
movl 0x18(%r10), %r12d
decl %r12d
leal 0x1(%rsi), %r15d
cmpl %r12d, %esi
cmovgel %r12d, %r15d
cmovll %esi, %r12d
movl 0x10(%r10), %r13d
cmpl %r13d, %esi
cmovll %r13d, %r12d
cmovll %r13d, %r15d
movl 0x1c(%r10), %esi
decl %esi
leal 0x1(%r14), %r13d
cmpl %esi, %r14d
cmovgel %esi, %r13d
cmovll %r14d, %esi
movl 0x14(%r10), %ebx
cmpl %ebx, %r14d
cmovll %ebx, %esi
cmovll %ebx, %r13d
movslq %esi, %rsi
imulq %r11, %rsi
addq %rdx, %rsi
movslq %r12d, %rbx
movslq %r15d, %r14
movd (%rsi,%r14,4), %xmm3
movd (%rsi,%rbx,4), %xmm1
movslq %r13d, %rsi
imulq %r11, %rsi
addq %rdx, %rsi
movd (%rsi,%r14,4), %xmm4
movd (%rsi,%rbx,4), %xmm2
shrl $0x8, %eax
movl $0xff, %ebx
andl %ebx, %eax
movl $0x100, %esi # imm = 0x100
subl %eax, %esi
movd %esi, %xmm5
shrl $0x8, %ebp
andl %ebx, %ebp
movd %eax, %xmm6
movl $0x100, %eax # imm = 0x100
subl %ebp, %eax
movd %eax, %xmm7
punpckldq %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
punpckldq %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
punpcklbw %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
pshuflw $0x0, %xmm5, %xmm3 # xmm3 = xmm5[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
pmullw %xmm1, %xmm3
punpcklbw %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3],xmm2[4],xmm0[4],xmm2[5],xmm0[5],xmm2[6],xmm0[6],xmm2[7],xmm0[7]
pshuflw $0x0, %xmm6, %xmm1 # xmm1 = xmm6[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
pmullw %xmm2, %xmm1
paddw %xmm3, %xmm1
movd %ebp, %xmm2
punpcklwd %xmm2, %xmm7 # xmm7 = xmm7[0],xmm2[0],xmm7[1],xmm2[1],xmm7[2],xmm2[2],xmm7[3],xmm2[3]
pshufd $0x0, %xmm7, %xmm2 # xmm2 = xmm7[0,0,0,0]
pshufd $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,2,1,3]
pshuflw $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,2,1,3,4,5,6,7]
pshufhw $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,1,2,3,4,6,5,7]
psrlw $0x8, %xmm1
pmaddwd %xmm2, %xmm1
psrld $0x8, %xmm1
packssdw %xmm1, %xmm1
packuswb %xmm1, %xmm1
movd %xmm1, (%rdi)
addl %r9d, (%rcx)
movl (%r8), %eax
movl 0x38(%rsp), %esi
addl %esi, %eax
movl %eax, (%r8)
addq $0x4, %rdi
cmpq -0x28(%rsp), %rdi
jb 0x55ba3f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %ebx, %rdx
subq %rdx, %rax
movslq %r14d, %rsi
jmp 0x55b646
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_fetcher<(TextureBlendType)5, (QPixelLayout::BPP)4, unsigned int>(unsigned int*, unsigned int*, int, QTextureData const&, int, int, int, int) | static void QT_FASTCALL fetchTransformedBilinear_fetcher(T *buf1, T *buf2, const int len, const QTextureData &image,
int fx, int fy, const int fdx, const int fdy)
{
const QPixelLayout &layout = qPixelLayouts[image.format];
constexpr bool useFetch = (bpp < QPixelLayout::BPP32);
if (useFetch)
Q_ASSERT(sizeof(T) == sizeof(uint));
else
Q_ASSERT(layout.bpp == bpp || (layout.bpp == QPixelLayout::BPP16FPx4 && bpp == QPixelLayout::BPP64));
const Fetch1PixelFunc fetch1 = (bpp == QPixelLayout::BPPNone) ? fetch1PixelTable[layout.bpp] : fetch1Pixel<bpp>;
if (fdy == 0) {
int y1 = (fy >> 16);
int y2;
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
const uchar *s1 = image.scanLine(y1);
const uchar *s2 = image.scanLine(y2);
int i = 0;
if (blendType == BlendTransformedBilinear) {
for (; i < len; ++i) {
int x1 = (fx >> 16);
int x2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
if (x1 != x2)
break;
if constexpr (useFetch) {
buf1[i * 2 + 0] = buf1[i * 2 + 1] = fetch1(s1, x1);
buf2[i * 2 + 0] = buf2[i * 2 + 1] = fetch1(s2, x1);
} else {
buf1[i * 2 + 0] = buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x1];
buf2[i * 2 + 0] = buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x1];
}
fx += fdx;
}
int fastLen = len;
if (fdx > 0)
fastLen = qMin(fastLen, int((qint64(image.x2 - 1) * fixed_scale - fx) / fdx));
else if (fdx < 0)
fastLen = qMin(fastLen, int((qint64(image.x1) * fixed_scale - fx) / fdx));
for (; i < fastLen; ++i) {
int x = (fx >> 16);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x);
buf1[i * 2 + 1] = fetch1(s1, x + 1);
buf2[i * 2 + 0] = fetch1(s2, x);
buf2[i * 2 + 1] = fetch1(s2, x + 1);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x + 1];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x + 1];
}
fx += fdx;
}
}
for (; i < len; ++i) {
int x1 = (fx >> 16);
int x2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x1);
buf1[i * 2 + 1] = fetch1(s1, x2);
buf2[i * 2 + 0] = fetch1(s2, x1);
buf2[i * 2 + 1] = fetch1(s2, x2);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x1];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x2];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x1];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x2];
}
fx += fdx;
}
} else {
int i = 0;
if (blendType == BlendTransformedBilinear) {
for (; i < len; ++i) {
int x1 = (fx >> 16);
int x2;
int y1 = (fy >> 16);
int y2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
if (x1 != x2 && y1 != y2)
break;
const uchar *s1 = image.scanLine(y1);
const uchar *s2 = image.scanLine(y2);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x1);
buf1[i * 2 + 1] = fetch1(s1, x2);
buf2[i * 2 + 0] = fetch1(s2, x1);
buf2[i * 2 + 1] = fetch1(s2, x2);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x1];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x2];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x1];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x2];
}
fx += fdx;
fy += fdy;
}
int fastLen = len;
if (fdx > 0)
fastLen = qMin(fastLen, int((qint64(image.x2 - 1) * fixed_scale - fx) / fdx));
else if (fdx < 0)
fastLen = qMin(fastLen, int((qint64(image.x1) * fixed_scale - fx) / fdx));
if (fdy > 0)
fastLen = qMin(fastLen, int((qint64(image.y2 - 1) * fixed_scale - fy) / fdy));
else if (fdy < 0)
fastLen = qMin(fastLen, int((qint64(image.y1) * fixed_scale - fy) / fdy));
for (; i < fastLen; ++i) {
int x = (fx >> 16);
int y = (fy >> 16);
const uchar *s1 = image.scanLine(y);
const uchar *s2 = s1 + image.bytesPerLine;
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x);
buf1[i * 2 + 1] = fetch1(s1, x + 1);
buf2[i * 2 + 0] = fetch1(s2, x);
buf2[i * 2 + 1] = fetch1(s2, x + 1);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x + 1];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x + 1];
}
fx += fdx;
fy += fdy;
}
}
for (; i < len; ++i) {
int x1 = (fx >> 16);
int x2;
int y1 = (fy >> 16);
int y2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
const uchar *s1 = image.scanLine(y1);
const uchar *s2 = image.scanLine(y2);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x1);
buf1[i * 2 + 1] = fetch1(s1, x2);
buf2[i * 2 + 0] = fetch1(s2, x1);
buf2[i * 2 + 1] = fetch1(s2, x2);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x1];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x2];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x1];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x2];
}
fx += fdx;
fy += fdy;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r10d
movl 0x40(%rsp), %r15d
movl 0x38(%rsp), %r12d
testl %r15d, %r15d
je 0x55e959
testl %r10d, %r10d
jle 0x55ea00
movq (%rcx), %rax
movq %rax, -0x8(%rsp)
movq 0x20(%rcx), %rax
movq %rax, -0x10(%rsp)
movl %r10d, %eax
movq %rax, -0x18(%rsp)
xorl %ebp, %ebp
movl %r8d, %eax
sarl $0x10, %eax
movl %r9d, %r10d
sarl $0x10, %r10d
movl 0x8(%rcx), %r13d
movl %r12d, %r14d
movl 0xc(%rcx), %r12d
cltd
idivl %r13d
movl %edx, %eax
sarl $0x1f, %eax
andl %r13d, %eax
leal (%rax,%rdx), %r11d
leal (%rax,%rdx), %ebx
incl %ebx
cmpl %r13d, %ebx
movl $0x0, %r13d
cmovel %r13d, %ebx
movl %r10d, %eax
cltd
idivl %r12d
movl %edx, %eax
sarl $0x1f, %eax
andl %r12d, %eax
leal (%rax,%rdx), %r10d
addl %edx, %eax
incl %eax
cmpl %r12d, %eax
movl %r14d, %r12d
cmovel %r13d, %eax
movslq %r10d, %rdx
movq -0x10(%rsp), %r13
imulq %r13, %rdx
movq -0x8(%rsp), %r14
addq %r14, %rdx
movslq %r11d, %r10
movzwl (%rdx,%r10,2), %r11d
movl %r11d, (%rdi,%rbp,8)
movslq %ebx, %r11
movzwl (%rdx,%r11,2), %edx
movl %edx, 0x4(%rdi,%rbp,8)
cltq
imulq %r13, %rax
addq %r14, %rax
movzwl (%rax,%r10,2), %edx
movl %edx, (%rsi,%rbp,8)
movzwl (%rax,%r11,2), %eax
movl %eax, 0x4(%rsi,%rbp,8)
addl %r12d, %r8d
addl %r15d, %r9d
incq %rbp
cmpq %rbp, -0x18(%rsp)
jne 0x55e89f
jmp 0x55ea00
sarl $0x10, %r9d
movl 0xc(%rcx), %ebx
movl %r9d, %eax
cltd
idivl %ebx
movl %edx, %eax
sarl $0x1f, %eax
andl %ebx, %eax
leal (%rax,%rdx), %r11d
incl %r11d
xorl %r9d, %r9d
cmpl %ebx, %r11d
cmovel %r9d, %r11d
testl %r10d, %r10d
jle 0x55ea00
addl %edx, %eax
movq (%rcx), %rdx
movslq %eax, %rbx
movq 0x20(%rcx), %rax
imulq %rax, %rbx
addq %rdx, %rbx
movslq %r11d, %r14
imulq %rax, %r14
addq %rdx, %r14
movl %r10d, %r10d
xorl %r15d, %r15d
movl %r8d, %eax
sarl $0x10, %eax
movl 0x8(%rcx), %r11d
cltd
idivl %r11d
movl %edx, %eax
sarl $0x1f, %eax
andl %r11d, %eax
leal (%rax,%rdx), %ebp
addl %edx, %eax
incl %eax
cmpl %r11d, %eax
cmovel %r9d, %eax
movslq %ebp, %rdx
movzwl (%rbx,%rdx,2), %r11d
movl %r11d, (%rdi,%r15,8)
cltq
movzwl (%rbx,%rax,2), %r11d
movl %r11d, 0x4(%rdi,%r15,8)
movzwl (%r14,%rdx,2), %edx
movl %edx, (%rsi,%r15,8)
movzwl (%r14,%rax,2), %eax
movl %eax, 0x4(%rsi,%r15,8)
addl %r12d, %r8d
incq %r15
cmpq %r15, %r10
jne 0x55e9a6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
unsigned int const* fetchTransformedBilinear<(TextureBlendType)5, (QPixelLayout::BPP)6>(unsigned int*, Operator const*, QSpanData const*, int, int, int) | static const uint *QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *,
const QSpanData *data, int y, int x, int length)
{
const QPixelLayout *layout = &qPixelLayouts[data->texture.format];
const QList<QRgb> *clut = data->texture.colorTable;
Q_ASSERT(bpp == QPixelLayout::BPPNone || layout->bpp == bpp);
const qreal cx = x + qreal(0.5);
const qreal cy = y + qreal(0.5);
if (canUseFastMatrixPath(cx, cy, length, data)) {
// The increment pr x in the scanline
int fdx = (int)(data->m11 * fixed_scale);
int fdy = (int)(data->m12 * fixed_scale);
int fx = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale);
int fy = int((data->m22 * cy + data->m12 * cx + data->dy) * fixed_scale);
fx -= half_point;
fy -= half_point;
if (fdy == 0) { // simple scale, no rotation or shear
if (qAbs(fdx) <= fixed_scale) { // scale up on X
fetchTransformedBilinear_simple_scale_helper<blendType>(buffer, buffer + length, data->texture, fx, fy, fdx, fdy);
} else if (qAbs(fdx) <= 2 * fixed_scale) { // scale down on X less than 2x
const int mid = (length * 2 < BufferSize) ? length : ((length + 1) / 2);
fetchTransformedBilinear_simple_scale_helper<blendType>(buffer, buffer + mid, data->texture, fx, fy, fdx, fdy);
if (mid != length)
fetchTransformedBilinear_simple_scale_helper<blendType>(buffer + mid, buffer + length, data->texture, fx, fy, fdx, fdy);
} else {
const auto fetcher = fetchTransformedBilinear_fetcher<blendType,bpp,uint>;
Q_DECL_UNINITIALIZED uint buf1[BufferSize];
Q_DECL_UNINITIALIZED uint buf2[BufferSize];
uint *b = buffer;
while (length) {
int len = qMin(length, BufferSize / 2);
fetcher(buf1, buf2, len, data->texture, fx, fy, fdx, 0);
layout->convertToARGB32PM(buf1, len * 2, clut);
layout->convertToARGB32PM(buf2, len * 2, clut);
if (hasFastInterpolate4() || qAbs(data->m22) < qreal(1./8.)) { // scale up more than 8x (on Y)
int disty = (fy & 0x0000ffff) >> 8;
for (int i = 0; i < len; ++i) {
int distx = (fx & 0x0000ffff) >> 8;
b[i] = interpolate_4_pixels(buf1 + i * 2, buf2 + i * 2, distx, disty);
fx += fdx;
}
} else {
int disty = ((fy & 0x0000ffff) + 0x0800) >> 12;
for (int i = 0; i < len; ++i) {
uint tl = buf1[i * 2 + 0];
uint tr = buf1[i * 2 + 1];
uint bl = buf2[i * 2 + 0];
uint br = buf2[i * 2 + 1];
int distx = ((fx & 0x0000ffff) + 0x0800) >> 12;
b[i] = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty);
fx += fdx;
}
}
length -= len;
b += len;
}
}
} else { // rotation or shear
const auto fetcher = fetchTransformedBilinear_fetcher<blendType,bpp,uint>;
Q_DECL_UNINITIALIZED uint buf1[BufferSize];
Q_DECL_UNINITIALIZED uint buf2[BufferSize];
uint *b = buffer;
while (length) {
int len = qMin(length, BufferSize / 2);
fetcher(buf1, buf2, len, data->texture, fx, fy, fdx, fdy);
layout->convertToARGB32PM(buf1, len * 2, clut);
layout->convertToARGB32PM(buf2, len * 2, clut);
if (hasFastInterpolate4() || qAbs(data->m11) < qreal(1./8.) || qAbs(data->m22) < qreal(1./8.)) {
// If we are zooming more than 8 times, we use 8bit precision for the position.
for (int i = 0; i < len; ++i) {
int distx = (fx & 0x0000ffff) >> 8;
int disty = (fy & 0x0000ffff) >> 8;
b[i] = interpolate_4_pixels(buf1 + i * 2, buf2 + i * 2, distx, disty);
fx += fdx;
fy += fdy;
}
} else {
// We are zooming less than 8x, use 4bit precision
for (int i = 0; i < len; ++i) {
uint tl = buf1[i * 2 + 0];
uint tr = buf1[i * 2 + 1];
uint bl = buf2[i * 2 + 0];
uint br = buf2[i * 2 + 1];
int distx = ((fx & 0x0000ffff) + 0x0800) >> 12;
int disty = ((fy & 0x0000ffff) + 0x0800) >> 12;
b[i] = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty);
fx += fdx;
fy += fdy;
}
}
length -= len;
b += len;
}
}
} else {
const auto fetcher = fetchTransformedBilinear_slow_fetcher<blendType,bpp,uint>;
const qreal fdx = data->m11;
const qreal fdy = data->m12;
const qreal fdw = data->m13;
qreal fx = data->m21 * cy + data->m11 * cx + data->dx;
qreal fy = data->m22 * cy + data->m12 * cx + data->dy;
qreal fw = data->m23 * cy + data->m13 * cx + data->m33;
Q_DECL_UNINITIALIZED uint buf1[BufferSize];
Q_DECL_UNINITIALIZED uint buf2[BufferSize];
uint *b = buffer;
Q_DECL_UNINITIALIZED ushort distxs[BufferSize / 2];
Q_DECL_UNINITIALIZED ushort distys[BufferSize / 2];
while (length) {
const int len = qMin(length, BufferSize / 2);
fetcher(buf1, buf2, distxs, distys, len, data->texture, fx, fy, fw, fdx, fdy, fdw);
layout->convertToARGB32PM(buf1, len * 2, clut);
layout->convertToARGB32PM(buf2, len * 2, clut);
for (int i = 0; i < len; ++i) {
const int distx = distxs[i] >> 8;
const int disty = distys[i] >> 8;
b[i] = interpolate_4_pixels(buf1 + i * 2, buf2 + i * 2, distx, disty);
}
length -= len;
b += len;
}
}
return buffer;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50f8, %rsp # imm = 0x50F8
movl %r9d, %r15d
movq %rdx, %r13
movq %rdi, 0x8(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x50f0(%rsp)
leaq 0xa8(%rdx), %rax
movq %rax, 0x28(%rsp)
movl 0xd0(%rdx), %eax
shlq $0x6, %rax
movq 0xd8(%rdx), %rdx
movq %rdx, 0x60(%rsp)
cvtsi2sd %r8d, %xmm1
movsd 0x159f0(%rip), %xmm0 # 0x574c50
addsd %xmm0, %xmm1
cvtsi2sd %ecx, %xmm4
addsd %xmm0, %xmm4
movsd 0x70(%r13), %xmm5
addq 0x18f88f(%rip), %rax # 0x6eeb08
movq %rax, 0x68(%rsp)
testb $0x1, 0x8a(%r13)
movapd %xmm1, 0x80(%rsp)
je 0x55f9b7
movupd 0x38(%r13), %xmm3
movupd 0x50(%r13), %xmm0
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
mulpd %xmm3, %xmm1
movapd %xmm4, 0x40(%rsp)
movapd %xmm4, %xmm2
unpcklpd %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm0, %xmm2
movhpd 0x78(%r13), %xmm5 # xmm5 = xmm5[0],mem[0]
addpd %xmm1, %xmm2
addpd %xmm2, %xmm5
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movapd %xmm0, 0xb0(%rsp)
movapd 0x3114e(%rip), %xmm1 # 0x590430
movapd %xmm5, 0x30(%rsp)
mulpd %xmm1, %xmm5
movapd %xmm5, 0xa0(%rsp)
movapd %xmm5, %xmm0
unpckhpd %xmm5, %xmm0 # xmm0 = xmm0[1],xmm5[1]
movapd %xmm0, 0x70(%rsp)
minsd %xmm5, %xmm0
movapd %xmm0, 0xc0(%rsp)
movapd %xmm3, 0x50(%rsp)
mulpd %xmm3, %xmm1
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x1409c0
movapd %xmm0, 0x90(%rsp)
movapd 0x10(%rsp), %xmm0
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
callq 0x1409c0
movapd 0xb0(%rsp), %xmm3
movapd 0xa0(%rsp), %xmm2
movapd 0x90(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
unpcklpd %xmm3, %xmm3 # xmm3 = xmm3[0,0]
mulpd %xmm1, %xmm3
addpd %xmm2, %xmm3
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0 # xmm0 = xmm0[1],xmm3[1]
movapd %xmm0, %xmm1
minsd %xmm3, %xmm1
minsd 0xc0(%rsp), %xmm1
ucomisd 0x15813(%rip), %xmm1 # 0x574ba0
jae 0x55f39d
movapd 0x40(%rsp), %xmm4
movdqa 0x30(%rsp), %xmm5
jmp 0x55f3cd
movapd 0x70(%rsp), %xmm1
maxsd %xmm2, %xmm1
maxsd %xmm3, %xmm0
maxsd %xmm1, %xmm0
movsd 0x157f1(%rip), %xmm1 # 0x574ba8
ucomisd %xmm0, %xmm1
movapd 0x40(%rsp), %xmm4
movdqa 0x30(%rsp), %xmm5
jae 0x55f5d4
movsd 0x48(%r13), %xmm0
movq %xmm5, 0xe8(%rsp)
movhpd %xmm5, 0xe0(%rsp)
movsd %xmm0, 0x40(%rsp)
movapd 0x80(%rsp), %xmm1
mulsd %xmm0, %xmm1
mulsd 0x60(%r13), %xmm4
addsd %xmm1, %xmm4
addsd 0x68(%r13), %xmm4
movsd %xmm4, 0xd8(%rsp)
testl %r15d, %r15d
je 0x55f5a6
movdqa 0x50(%rsp), %xmm0
punpckhqdq %xmm0, %xmm0 # xmm0 = xmm0[1,1]
movdqa %xmm0, 0x30(%rsp)
movq 0x8(%rsp), %r12
movq 0x60(%rsp), %rbp
movq %r15, 0x10(%rsp)
movl $0x400, %eax # imm = 0x400
cmpl %eax, %r15d
movl $0x400, %ebx # imm = 0x400
cmovll %r15d, %ebx
subq $0x8, %rsp
leaq 0x30f8(%rsp), %r13
movq %r13, %rdi
leaq 0x10f8(%rsp), %r15
movq %r15, %rsi
leaq 0x8f8(%rsp), %rdx
leaq 0xf8(%rsp), %rcx
movl %ebx, %r8d
movq 0x30(%rsp), %r9
movdqa 0x58(%rsp), %xmm0
movdqa 0x38(%rsp), %xmm1
movq 0x48(%rsp), %xmm2
leaq 0xe0(%rsp), %rax
pushq %rax
leaq 0xf0(%rsp), %rax
pushq %rax
leaq 0x100(%rsp), %rax
pushq %rax
callq 0x5602ff
addq $0x20, %rsp
leal (%rbx,%rbx), %r14d
movq %r13, %rdi
movl %r14d, %esi
movq %rbp, %rdx
movq 0x68(%rsp), %r13
callq *0x10(%r13)
movq %r15, %rdi
movq 0x10(%rsp), %r15
movl %r14d, %esi
movq %rbp, %rdx
callq *0x10(%r13)
xorpd %xmm3, %xmm3
testl %r15d, %r15d
jle 0x55f596
movl %ebx, %eax
xorl %ecx, %ecx
movzwl 0x8f0(%rsp,%rcx,2), %edx
shrl $0x8, %edx
movzbl 0xf1(%rsp,%rcx,2), %esi
movq 0x30f0(%rsp,%rcx,8), %xmm0
movq 0x10f0(%rsp,%rcx,8), %xmm1
punpcklbw %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1],xmm0[2],xmm3[2],xmm0[3],xmm3[3],xmm0[4],xmm3[4],xmm0[5],xmm3[5],xmm0[6],xmm3[6],xmm0[7],xmm3[7]
punpcklbw %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1],xmm1[2],xmm3[2],xmm1[3],xmm3[3],xmm1[4],xmm3[4],xmm1[5],xmm3[5],xmm1[6],xmm3[6],xmm1[7],xmm3[7]
movl $0x100, %edi # imm = 0x100
subl %esi, %edi
movd %edi, %xmm2
pshuflw $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
pmullw %xmm0, %xmm2
movd %esi, %xmm0
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
pmullw %xmm1, %xmm0
paddw %xmm2, %xmm0
movl $0x100, %esi # imm = 0x100
subl %edx, %esi
movd %esi, %xmm1
movd %edx, %xmm2
punpcklwd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
pshufd $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,1,3]
pshuflw $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,1,3,4,5,6,7]
pshufhw $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2,3,4,6,5,7]
psrlw $0x8, %xmm0
pmaddwd %xmm1, %xmm0
psrld $0x8, %xmm0
packssdw %xmm0, %xmm0
packuswb %xmm0, %xmm0
movd %xmm0, (%r12,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x55f4eb
movslq %ebx, %rax
leaq (%r12,%rax,4), %r12
subl %ebx, %r15d
jne 0x55f434
movq %fs:0x28, %rax
cmpq 0x50f0(%rsp), %rax
jne 0x55f9f0
movq 0x8(%rsp), %rax
addq $0x50f8, %rsp # imm = 0x50F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cvttpd2dq 0x10(%rsp), %xmm4
pshufd $0x55, %xmm4, %xmm0 # xmm0 = xmm4[1,1,1,1]
movd %xmm0, %eax
cvttpd2dq %xmm2, %xmm3
paddd 0x6eca1(%rip), %xmm3 # 0x5ce290
movd %xmm3, 0x8f0(%rsp)
movq %rax, 0x50(%rsp)
testl %eax, %eax
je 0x55f783
testl %r15d, %r15d
je 0x55f5a6
movd %xmm4, %eax
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rbp
movaps %xmm4, 0x30(%rsp)
movq 0x60(%rsp), %r13
movl $0x400, %eax # imm = 0x400
cmpl %eax, %r15d
movl $0x400, %ebx # imm = 0x400
cmovll %r15d, %ebx
movd %xmm3, %r8d
movdqa %xmm3, 0x10(%rsp)
pshufd $0x55, %xmm3, %xmm0 # xmm0 = xmm3[1,1,1,1]
movd %xmm0, %r9d
leaq 0x30f0(%rsp), %r12
movq %r12, %rdi
leaq 0x10f0(%rsp), %rsi
movl %ebx, %edx
movq 0x28(%rsp), %rcx
pushq 0x50(%rsp)
pushq 0x48(%rsp)
callq 0x560153
addq $0x10, %rsp
leal (%rbx,%rbx), %r14d
movq %r12, %rdi
movl %r14d, %esi
movq %r13, %rdx
movq 0x68(%rsp), %r12
callq *0x10(%r12)
leaq 0x10f0(%rsp), %rdi
movl %r14d, %esi
movq %r13, %rdx
callq *0x10(%r12)
testl %r15d, %r15d
jle 0x55f767
movl %ebx, %eax
xorl %ecx, %ecx
movdqa 0x10(%rsp), %xmm3
movdqa 0x30(%rsp), %xmm4
pxor %xmm5, %xmm5
movd %xmm3, %edx
movzbl %dh, %edx
movq 0x30f0(%rsp,%rcx,8), %xmm0
movq 0x10f0(%rsp,%rcx,8), %xmm1
punpcklbw %xmm5, %xmm0 # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1],xmm0[2],xmm5[2],xmm0[3],xmm5[3],xmm0[4],xmm5[4],xmm0[5],xmm5[5],xmm0[6],xmm5[6],xmm0[7],xmm5[7]
punpcklbw %xmm5, %xmm1 # xmm1 = xmm1[0],xmm5[0],xmm1[1],xmm5[1],xmm1[2],xmm5[2],xmm1[3],xmm5[3],xmm1[4],xmm5[4],xmm1[5],xmm5[5],xmm1[6],xmm5[6],xmm1[7],xmm5[7]
pextrw $0x2, %xmm3, %esi
shrl $0x8, %esi
movl $0x100, %edi # imm = 0x100
subl %esi, %edi
movd %edi, %xmm2
pshuflw $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
pmullw %xmm0, %xmm2
movd %esi, %xmm0
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
pmullw %xmm1, %xmm0
paddw %xmm2, %xmm0
movl $0x100, %esi # imm = 0x100
subl %edx, %esi
movd %esi, %xmm1
movd %edx, %xmm2
punpcklwd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
pshufd $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,1,3]
pshuflw $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,1,3,4,5,6,7]
pshufhw $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2,3,4,6,5,7]
psrlw $0x8, %xmm0
pmaddwd %xmm1, %xmm0
psrld $0x8, %xmm0
packssdw %xmm0, %xmm0
packuswb %xmm0, %xmm0
movd %xmm0, (%rbp,%rcx,4)
paddd %xmm4, %xmm3
incq %rcx
cmpq %rcx, %rax
jne 0x55f6ba
jmp 0x55f76d
movdqa 0x10(%rsp), %xmm3
movslq %ebx, %rax
leaq (%rbp,%rax,4), %rbp
subl %ebx, %r15d
jne 0x55f622
jmp 0x55f5a6
movslq %r15d, %r12
movd %xmm4, %r13d
movl %r13d, %eax
negl %eax
cmovsl %r13d, %eax
cmpl $0x10000, %eax # imm = 0x10000
ja 0x55f7c8
movq 0x8(%rsp), %rdi
leaq (%rdi,%r12,4), %rsi
pshufd $0x55, %xmm3, %xmm0 # xmm0 = xmm3[1,1,1,1]
movd %xmm0, %r8d
leaq 0x8f0(%rsp), %rcx
movq 0x28(%rsp), %rdx
movl %r13d, %r9d
callq 0x55e543
jmp 0x55f5a6
cmpl $0x20000, %eax # imm = 0x20000
ja 0x55f840
leal 0x1(%r15), %eax
shrl %eax
cmpl $0x400, %r15d # imm = 0x400
cmovll %r15d, %eax
movslq %eax, %rbp
movq 0x8(%rsp), %rdi
leaq (%rdi,%rbp,4), %r14
pshufd $0x55, %xmm3, %xmm0 # xmm0 = xmm3[1,1,1,1]
movd %xmm0, %r8d
leaq 0x8f0(%rsp), %rcx
movq %r14, %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdx
movl %r8d, 0x10(%rsp)
movl %r13d, %r9d
callq 0x55e543
cmpl %r15d, %ebp
je 0x55f5a6
movq 0x8(%rsp), %rax
leaq (%rax,%r12,4), %rsi
leaq 0x8f0(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
movl 0x10(%rsp), %r8d
jmp 0x55f7bb
testl %r15d, %r15d
je 0x55f5a6
movd %xmm3, %eax
pshufd $0x55, %xmm3, %xmm0 # xmm0 = xmm3[1,1,1,1]
movd %xmm0, %ecx
movl %ecx, 0x50(%rsp)
movzbl %ch, %ecx
movl $0x100, %edx # imm = 0x100
subl %ecx, %edx
movd %edx, %xmm1
pshuflw $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm3 # xmm3 = xmm1[0,0,0,0]
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm4 # xmm4 = xmm0[0,0,0,0]
psrlw $0x8, %xmm4
movq 0x8(%rsp), %r12
movdqa %xmm3, 0x40(%rsp)
movdqa %xmm4, 0x30(%rsp)
movq 0x60(%rsp), %rbp
movl $0x400, %ecx # imm = 0x400
cmpl %ecx, %r15d
movl $0x400, %ebx # imm = 0x400
cmovll %r15d, %ebx
leaq 0x30f0(%rsp), %r14
movq %r14, %rdi
leaq 0x10f0(%rsp), %rsi
movl %ebx, %edx
movq 0x28(%rsp), %rcx
movl %eax, %r8d
movl 0x50(%rsp), %r9d
pushq $0x0
pushq %r13
callq 0x560153
addq $0x10, %rsp
leal (%rbx,%rbx), %esi
movl %esi, 0x10(%rsp)
movq %r14, %rdi
movq %rbp, %rdx
movq 0x68(%rsp), %r14
callq *0x10(%r14)
leaq 0x10f0(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rbp, %rdx
callq *0x10(%r14)
movl 0x8f0(%rsp), %eax
testl %r15d, %r15d
jle 0x55f99b
movl %ebx, %ecx
xorl %edx, %edx
movdqa 0x40(%rsp), %xmm3
movdqa 0x30(%rsp), %xmm4
pxor %xmm5, %xmm5
movzbl %ah, %esi
movq 0x30f0(%rsp,%rdx,8), %xmm0
movq 0x10f0(%rsp,%rdx,8), %xmm1
punpcklbw %xmm5, %xmm0 # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1],xmm0[2],xmm5[2],xmm0[3],xmm5[3],xmm0[4],xmm5[4],xmm0[5],xmm5[5],xmm0[6],xmm5[6],xmm0[7],xmm5[7]
pmullw %xmm3, %xmm0
punpcklbw %xmm5, %xmm1 # xmm1 = xmm1[0],xmm5[0],xmm1[1],xmm5[1],xmm1[2],xmm5[2],xmm1[3],xmm5[3],xmm1[4],xmm5[4],xmm1[5],xmm5[5],xmm1[6],xmm5[6],xmm1[7],xmm5[7]
pmullw %xmm4, %xmm1
paddw %xmm0, %xmm1
movl $0x100, %edi # imm = 0x100
subl %esi, %edi
movd %edi, %xmm0
movd %esi, %xmm2
punpcklwd %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1],xmm0[2],xmm2[2],xmm0[3],xmm2[3]
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
pshufd $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,2,1,3]
pshuflw $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,2,1,3,4,5,6,7]
pshufhw $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,1,2,3,4,6,5,7]
psrlw $0x8, %xmm1
pmaddwd %xmm0, %xmm1
psrld $0x8, %xmm1
packssdw %xmm1, %xmm1
packuswb %xmm1, %xmm1
movd %xmm1, (%r12,%rdx,4)
addl %r13d, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x55f924
movl %eax, 0x8f0(%rsp)
movslq %ebx, %rcx
leaq (%r12,%rcx,4), %r12
subl %ebx, %r15d
jne 0x55f897
jmp 0x55f5a6
movupd 0x38(%r13), %xmm2
movupd 0x50(%r13), %xmm0
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
movapd %xmm2, 0x50(%rsp)
mulpd %xmm2, %xmm1
movapd %xmm4, %xmm2
unpcklpd %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
movhpd 0x78(%r13), %xmm5 # xmm5 = xmm5[0],mem[0]
addpd %xmm2, %xmm5
jmp 0x55f3cd
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_slow_fetcher<(TextureBlendType)4, (QPixelLayout::BPP)6, unsigned int>(unsigned int*, unsigned int*, unsigned short*, unsigned short*, int, QTextureData const&, double&, double&, double&, double, double, double) | static void QT_FASTCALL fetchTransformedBilinear_slow_fetcher(T *buf1, T *buf2, ushort *distxs, ushort *distys,
const int len, const QTextureData &image,
qreal &fx, qreal &fy, qreal &fw,
const qreal fdx, const qreal fdy, const qreal fdw)
{
const QPixelLayout &layout = qPixelLayouts[image.format];
constexpr bool useFetch = (bpp < QPixelLayout::BPP32);
if (useFetch)
Q_ASSERT(sizeof(T) == sizeof(uint));
else
Q_ASSERT(layout.bpp == bpp);
const Fetch1PixelFunc fetch1 = (bpp == QPixelLayout::BPPNone) ? fetch1PixelTable[layout.bpp] : fetch1Pixel<bpp>;
for (int i = 0; i < len; ++i) {
const qreal iw = fw == 0 ? 16384 : 1 / fw;
const qreal px = fx * iw - qreal(0.5);
const qreal py = fy * iw - qreal(0.5);
int x1 = qFloor(px);
int x2;
int y1 = qFloor(py);
int y2;
distxs[i] = ushort((px - x1) * (1<<16));
distys[i] = ushort((py - y1) * (1<<16));
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
const uchar *s1 = image.scanLine(y1);
const uchar *s2 = image.scanLine(y2);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x1);
buf1[i * 2 + 1] = fetch1(s1, x2);
buf2[i * 2 + 0] = fetch1(s2, x1);
buf2[i * 2 + 1] = fetch1(s2, x2);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x1];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x2];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x1];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x2];
}
fx += fdx;
fy += fdy;
fw += fdw;
}
} | endbr64
testl %r8d, %r8d
jle 0x560152
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %rbx
movq %rcx, %r13
movq %rdi, %rbp
movq 0xc0(%rsp), %rax
movq (%r9), %r9
movq %r9, 0x20(%rsp)
movq 0x20(%rbx), %r9
movq %r9, 0x18(%rsp)
movl %r8d, %r8d
movq %r8, 0x10(%rsp)
movsd (%rax), %xmm4
xorl %r14d, %r14d
movsd %xmm2, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movsd 0x147e8(%rip), %xmm1 # 0x574760
divsd %xmm4, %xmm1
cmpeqsd 0x224a3(%rip), %xmm4 # 0x582428
movapd %xmm4, %xmm2
andnpd %xmm1, %xmm2
movsd 0x6e34b(%rip), %xmm1 # 0x5ce2e0
andpd %xmm1, %xmm4
orpd %xmm2, %xmm4
movq 0xb0(%rsp), %rax
movsd (%rax), %xmm1
movsd %xmm1, 0x48(%rsp)
movapd %xmm4, %xmm0
mulsd %xmm1, %xmm0
movsd 0x42c71(%rip), %xmm1 # 0x5a2c30
addsd %xmm1, %xmm0
movapd %xmm0, 0x60(%rsp)
movq 0xb8(%rsp), %rax
movsd (%rax), %xmm2
mulsd %xmm4, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movq %rdx, %r15
callq 0x138490
movapd %xmm0, 0x50(%rsp)
cvttsd2si %xmm0, %r12d
movsd 0x8(%rsp), %xmm0
callq 0x138490
movq %r15, %rdx
movsd 0x30(%rsp), %xmm3
movsd 0x40(%rsp), %xmm2
cvttsd2si %xmm0, %eax
cvttpd2dq 0x50(%rsp), %xmm1
cvtdq2pd %xmm1, %xmm1
movapd 0x60(%rsp), %xmm5
subsd %xmm1, %xmm5
movsd 0x38(%rsp), %xmm1
movsd 0x15eda(%rip), %xmm4 # 0x575f10
mulsd %xmm4, %xmm5
cvttsd2si %xmm5, %esi
movw %si, (%r15,%r14,2)
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm5
subsd %xmm0, %xmm5
mulsd %xmm4, %xmm5
cvttsd2si %xmm5, %esi
movw %si, (%r13,%r14,2)
movl 0x18(%rbx), %esi
decl %esi
leal 0x1(%r12), %r9d
cmpl %r12d, %esi
movl %r12d, %r10d
cmovll %esi, %r10d
cmovlel %esi, %r9d
movl 0x10(%rbx), %esi
cmpl %r12d, %esi
cmovgl %esi, %r10d
cmovgl %esi, %r9d
movl 0x1c(%rbx), %esi
decl %esi
leal 0x1(%rax), %r11d
cmpl %eax, %esi
movl %eax, %r8d
cmovll %esi, %r8d
cmovlel %esi, %r11d
movl 0x14(%rbx), %esi
cmpl %eax, %esi
cmovgl %esi, %r8d
cmovgl %esi, %r11d
movslq %r8d, %rax
movq 0x18(%rsp), %r12
imulq %r12, %rax
movq 0x20(%rsp), %r15
addq %r15, %rax
movslq %r10d, %r8
movl (%rax,%r8,4), %esi
movl %esi, (%rbp,%r14,8)
movslq %r9d, %r9
movq 0x28(%rsp), %rsi
movl (%rax,%r9,4), %eax
movl %eax, 0x4(%rbp,%r14,8)
movslq %r11d, %rax
imulq %r12, %rax
addq %r15, %rax
movl (%rax,%r8,4), %r8d
movl %r8d, (%rsi,%r14,8)
movl (%rax,%r9,4), %eax
movl %eax, 0x4(%rsi,%r14,8)
movsd 0x48(%rsp), %xmm0
addsd %xmm3, %xmm0
movq 0xb0(%rsp), %rax
movsd %xmm0, (%rax)
movq 0xb8(%rsp), %rax
movsd (%rax), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq 0xc0(%rsp), %rax
movsd (%rax), %xmm4
addsd %xmm2, %xmm4
movsd %xmm4, (%rax)
incq %r14
cmpq %r14, 0x10(%rsp)
jne 0x55ff70
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_slow_fetcher<(TextureBlendType)5, (QPixelLayout::BPP)6, unsigned int>(unsigned int*, unsigned int*, unsigned short*, unsigned short*, int, QTextureData const&, double&, double&, double&, double, double, double) | static void QT_FASTCALL fetchTransformedBilinear_slow_fetcher(T *buf1, T *buf2, ushort *distxs, ushort *distys,
const int len, const QTextureData &image,
qreal &fx, qreal &fy, qreal &fw,
const qreal fdx, const qreal fdy, const qreal fdw)
{
const QPixelLayout &layout = qPixelLayouts[image.format];
constexpr bool useFetch = (bpp < QPixelLayout::BPP32);
if (useFetch)
Q_ASSERT(sizeof(T) == sizeof(uint));
else
Q_ASSERT(layout.bpp == bpp);
const Fetch1PixelFunc fetch1 = (bpp == QPixelLayout::BPPNone) ? fetch1PixelTable[layout.bpp] : fetch1Pixel<bpp>;
for (int i = 0; i < len; ++i) {
const qreal iw = fw == 0 ? 16384 : 1 / fw;
const qreal px = fx * iw - qreal(0.5);
const qreal py = fy * iw - qreal(0.5);
int x1 = qFloor(px);
int x2;
int y1 = qFloor(py);
int y2;
distxs[i] = ushort((px - x1) * (1<<16));
distys[i] = ushort((py - y1) * (1<<16));
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
const uchar *s1 = image.scanLine(y1);
const uchar *s2 = image.scanLine(y2);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x1);
buf1[i * 2 + 1] = fetch1(s1, x2);
buf2[i * 2 + 0] = fetch1(s2, x1);
buf2[i * 2 + 1] = fetch1(s2, x2);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x1];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x2];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x1];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x2];
}
fx += fdx;
fy += fdy;
fw += fdw;
}
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x8(%rsp)
testl %r8d, %r8d
jle 0x560541
movq %rdx, %r11
movq %rsi, %r14
movq 0xc0(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %r9
movq %r9, 0x28(%rsp)
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movl %r8d, %eax
movq %rax, 0x18(%rsp)
movsd (%rdx), %xmm4
xorl %r12d, %r12d
movsd %xmm2, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd 0x143f4(%rip), %xmm1 # 0x574760
divsd %xmm4, %xmm1
cmpeqsd 0x220af(%rip), %xmm4 # 0x582428
movapd %xmm4, %xmm2
andnpd %xmm1, %xmm2
movsd 0x6df57(%rip), %xmm1 # 0x5ce2e0
andpd %xmm1, %xmm4
orpd %xmm2, %xmm4
movq 0xb0(%rsp), %rax
movsd (%rax), %xmm1
movsd %xmm1, 0x48(%rsp)
movapd %xmm4, %xmm0
mulsd %xmm1, %xmm0
movsd 0x4287d(%rip), %xmm1 # 0x5a2c30
addsd %xmm1, %xmm0
movapd %xmm0, 0x60(%rsp)
movq 0xb8(%rsp), %rax
movsd (%rax), %xmm2
mulsd %xmm4, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
movq %rcx, %r13
movq %r11, %rbx
movq %rdi, %r15
callq 0x138490
movapd %xmm0, 0x50(%rsp)
cvttsd2si %xmm0, %ebp
movsd 0x10(%rsp), %xmm0
callq 0x138490
movq %rbx, %r11
movq %r13, %rcx
movsd 0x30(%rsp), %xmm3
movsd 0x40(%rsp), %xmm2
cvttsd2si %xmm0, %r10d
cvttpd2dq 0x50(%rsp), %xmm1
cvtdq2pd %xmm1, %xmm1
movapd 0x60(%rsp), %xmm5
subsd %xmm1, %xmm5
movsd 0x38(%rsp), %xmm1
movsd 0x15add(%rip), %xmm4 # 0x575f10
mulsd %xmm4, %xmm5
cvttsd2si %xmm5, %eax
cvttpd2dq %xmm0, %xmm0
movw %ax, (%rbx,%r12,2)
cvtdq2pd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm5
subsd %xmm0, %xmm5
mulsd %xmm4, %xmm5
cvttsd2si %xmm5, %eax
movw %ax, (%r13,%r12,2)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %r9d
movl 0xc(%rax), %r8d
movl %ebp, %eax
cltd
idivl %r9d
movl %edx, %eax
sarl $0x1f, %eax
andl %r9d, %eax
leal (%rax,%rdx), %esi
leal (%rax,%rdx), %ebx
incl %ebx
cmpl %r9d, %ebx
movl $0x0, %r13d
cmovel %r13d, %ebx
movl %r10d, %eax
movq %r15, %rdi
cltd
idivl %r8d
movl %edx, %eax
sarl $0x1f, %eax
andl %r8d, %eax
leal (%rax,%rdx), %r9d
addl %edx, %eax
incl %eax
cmpl %r8d, %eax
cmovel %r13d, %eax
movslq %r9d, %r8
movq 0x20(%rsp), %r15
imulq %r15, %r8
movq 0x28(%rsp), %r10
addq %r10, %r8
movslq %esi, %rdx
movl (%r8,%rdx,4), %esi
movl %esi, (%rdi,%r12,8)
movslq %ebx, %r9
movl (%r8,%r9,4), %esi
movl %esi, 0x4(%rdi,%r12,8)
cltq
imulq %r15, %rax
addq %r10, %rax
movl (%rax,%rdx,4), %edx
movl %edx, (%r14,%r12,8)
movl (%rax,%r9,4), %eax
movl %eax, 0x4(%r14,%r12,8)
movsd 0x48(%rsp), %xmm0
addsd %xmm3, %xmm0
movq 0xb0(%rsp), %rax
movsd %xmm0, (%rax)
movq 0xb8(%rsp), %rax
movsd (%rax), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq 0xc0(%rsp), %rax
movsd (%rax), %xmm4
addsd %xmm2, %xmm4
movsd %xmm4, (%rax)
incq %r12
cmpq %r12, 0x18(%rsp)
jne 0x560364
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
unsigned int const* fetchTransformedBilinear<(TextureBlendType)5, (QPixelLayout::BPP)0>(unsigned int*, Operator const*, QSpanData const*, int, int, int) | static const uint *QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *,
const QSpanData *data, int y, int x, int length)
{
const QPixelLayout *layout = &qPixelLayouts[data->texture.format];
const QList<QRgb> *clut = data->texture.colorTable;
Q_ASSERT(bpp == QPixelLayout::BPPNone || layout->bpp == bpp);
const qreal cx = x + qreal(0.5);
const qreal cy = y + qreal(0.5);
if (canUseFastMatrixPath(cx, cy, length, data)) {
// The increment pr x in the scanline
int fdx = (int)(data->m11 * fixed_scale);
int fdy = (int)(data->m12 * fixed_scale);
int fx = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale);
int fy = int((data->m22 * cy + data->m12 * cx + data->dy) * fixed_scale);
fx -= half_point;
fy -= half_point;
if (fdy == 0) { // simple scale, no rotation or shear
if (qAbs(fdx) <= fixed_scale) { // scale up on X
fetchTransformedBilinear_simple_scale_helper<blendType>(buffer, buffer + length, data->texture, fx, fy, fdx, fdy);
} else if (qAbs(fdx) <= 2 * fixed_scale) { // scale down on X less than 2x
const int mid = (length * 2 < BufferSize) ? length : ((length + 1) / 2);
fetchTransformedBilinear_simple_scale_helper<blendType>(buffer, buffer + mid, data->texture, fx, fy, fdx, fdy);
if (mid != length)
fetchTransformedBilinear_simple_scale_helper<blendType>(buffer + mid, buffer + length, data->texture, fx, fy, fdx, fdy);
} else {
const auto fetcher = fetchTransformedBilinear_fetcher<blendType,bpp,uint>;
Q_DECL_UNINITIALIZED uint buf1[BufferSize];
Q_DECL_UNINITIALIZED uint buf2[BufferSize];
uint *b = buffer;
while (length) {
int len = qMin(length, BufferSize / 2);
fetcher(buf1, buf2, len, data->texture, fx, fy, fdx, 0);
layout->convertToARGB32PM(buf1, len * 2, clut);
layout->convertToARGB32PM(buf2, len * 2, clut);
if (hasFastInterpolate4() || qAbs(data->m22) < qreal(1./8.)) { // scale up more than 8x (on Y)
int disty = (fy & 0x0000ffff) >> 8;
for (int i = 0; i < len; ++i) {
int distx = (fx & 0x0000ffff) >> 8;
b[i] = interpolate_4_pixels(buf1 + i * 2, buf2 + i * 2, distx, disty);
fx += fdx;
}
} else {
int disty = ((fy & 0x0000ffff) + 0x0800) >> 12;
for (int i = 0; i < len; ++i) {
uint tl = buf1[i * 2 + 0];
uint tr = buf1[i * 2 + 1];
uint bl = buf2[i * 2 + 0];
uint br = buf2[i * 2 + 1];
int distx = ((fx & 0x0000ffff) + 0x0800) >> 12;
b[i] = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty);
fx += fdx;
}
}
length -= len;
b += len;
}
}
} else { // rotation or shear
const auto fetcher = fetchTransformedBilinear_fetcher<blendType,bpp,uint>;
Q_DECL_UNINITIALIZED uint buf1[BufferSize];
Q_DECL_UNINITIALIZED uint buf2[BufferSize];
uint *b = buffer;
while (length) {
int len = qMin(length, BufferSize / 2);
fetcher(buf1, buf2, len, data->texture, fx, fy, fdx, fdy);
layout->convertToARGB32PM(buf1, len * 2, clut);
layout->convertToARGB32PM(buf2, len * 2, clut);
if (hasFastInterpolate4() || qAbs(data->m11) < qreal(1./8.) || qAbs(data->m22) < qreal(1./8.)) {
// If we are zooming more than 8 times, we use 8bit precision for the position.
for (int i = 0; i < len; ++i) {
int distx = (fx & 0x0000ffff) >> 8;
int disty = (fy & 0x0000ffff) >> 8;
b[i] = interpolate_4_pixels(buf1 + i * 2, buf2 + i * 2, distx, disty);
fx += fdx;
fy += fdy;
}
} else {
// We are zooming less than 8x, use 4bit precision
for (int i = 0; i < len; ++i) {
uint tl = buf1[i * 2 + 0];
uint tr = buf1[i * 2 + 1];
uint bl = buf2[i * 2 + 0];
uint br = buf2[i * 2 + 1];
int distx = ((fx & 0x0000ffff) + 0x0800) >> 12;
int disty = ((fy & 0x0000ffff) + 0x0800) >> 12;
b[i] = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty);
fx += fdx;
fy += fdy;
}
}
length -= len;
b += len;
}
}
} else {
const auto fetcher = fetchTransformedBilinear_slow_fetcher<blendType,bpp,uint>;
const qreal fdx = data->m11;
const qreal fdy = data->m12;
const qreal fdw = data->m13;
qreal fx = data->m21 * cy + data->m11 * cx + data->dx;
qreal fy = data->m22 * cy + data->m12 * cx + data->dy;
qreal fw = data->m23 * cy + data->m13 * cx + data->m33;
Q_DECL_UNINITIALIZED uint buf1[BufferSize];
Q_DECL_UNINITIALIZED uint buf2[BufferSize];
uint *b = buffer;
Q_DECL_UNINITIALIZED ushort distxs[BufferSize / 2];
Q_DECL_UNINITIALIZED ushort distys[BufferSize / 2];
while (length) {
const int len = qMin(length, BufferSize / 2);
fetcher(buf1, buf2, distxs, distys, len, data->texture, fx, fy, fw, fdx, fdy, fdw);
layout->convertToARGB32PM(buf1, len * 2, clut);
layout->convertToARGB32PM(buf2, len * 2, clut);
for (int i = 0; i < len; ++i) {
const int distx = distxs[i] >> 8;
const int disty = distys[i] >> 8;
b[i] = interpolate_4_pixels(buf1 + i * 2, buf2 + i * 2, distx, disty);
}
length -= len;
b += len;
}
}
return buffer;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50f8, %rsp # imm = 0x50F8
movl %r9d, %r15d
movq %rdx, %r13
movq %rdi, 0x8(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x50f0(%rsp)
leaq 0xa8(%rdx), %rax
movq %rax, 0x28(%rsp)
movl 0xd0(%rdx), %eax
shlq $0x6, %rax
movq 0xd8(%rdx), %rdx
movq %rdx, 0x60(%rsp)
cvtsi2sd %r8d, %xmm1
movsd 0x13dfd(%rip), %xmm0 # 0x574c50
addsd %xmm0, %xmm1
cvtsi2sd %ecx, %xmm4
addsd %xmm0, %xmm4
movsd 0x70(%r13), %xmm5
addq 0x18dc9c(%rip), %rax # 0x6eeb08
movq %rax, 0x68(%rsp)
testb $0x1, 0x8a(%r13)
movapd %xmm1, 0x80(%rsp)
je 0x5615aa
movupd 0x38(%r13), %xmm3
movupd 0x50(%r13), %xmm0
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
mulpd %xmm3, %xmm1
movapd %xmm4, 0x40(%rsp)
movapd %xmm4, %xmm2
unpcklpd %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm0, %xmm2
movhpd 0x78(%r13), %xmm5 # xmm5 = xmm5[0],mem[0]
addpd %xmm1, %xmm2
addpd %xmm2, %xmm5
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movapd %xmm0, 0xb0(%rsp)
movapd 0x2f55b(%rip), %xmm1 # 0x590430
movapd %xmm5, 0x30(%rsp)
mulpd %xmm1, %xmm5
movapd %xmm5, 0xa0(%rsp)
movapd %xmm5, %xmm0
unpckhpd %xmm5, %xmm0 # xmm0 = xmm0[1],xmm5[1]
movapd %xmm0, 0x70(%rsp)
minsd %xmm5, %xmm0
movapd %xmm0, 0xc0(%rsp)
movapd %xmm3, 0x50(%rsp)
mulpd %xmm3, %xmm1
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x1409c0
movapd %xmm0, 0x90(%rsp)
movapd 0x10(%rsp), %xmm0
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
callq 0x1409c0
movapd 0xb0(%rsp), %xmm3
movapd 0xa0(%rsp), %xmm2
movapd 0x90(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
unpcklpd %xmm3, %xmm3 # xmm3 = xmm3[0,0]
mulpd %xmm1, %xmm3
addpd %xmm2, %xmm3
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0 # xmm0 = xmm0[1],xmm3[1]
movapd %xmm0, %xmm1
minsd %xmm3, %xmm1
minsd 0xc0(%rsp), %xmm1
ucomisd 0x13c20(%rip), %xmm1 # 0x574ba0
jae 0x560f90
movapd 0x40(%rsp), %xmm4
movdqa 0x30(%rsp), %xmm5
jmp 0x560fc0
movapd 0x70(%rsp), %xmm1
maxsd %xmm2, %xmm1
maxsd %xmm3, %xmm0
maxsd %xmm1, %xmm0
movsd 0x13bfe(%rip), %xmm1 # 0x574ba8
ucomisd %xmm0, %xmm1
movapd 0x40(%rsp), %xmm4
movdqa 0x30(%rsp), %xmm5
jae 0x5611c7
movsd 0x48(%r13), %xmm0
movq %xmm5, 0xe8(%rsp)
movhpd %xmm5, 0xe0(%rsp)
movsd %xmm0, 0x40(%rsp)
movapd 0x80(%rsp), %xmm1
mulsd %xmm0, %xmm1
mulsd 0x60(%r13), %xmm4
addsd %xmm1, %xmm4
addsd 0x68(%r13), %xmm4
movsd %xmm4, 0xd8(%rsp)
testl %r15d, %r15d
je 0x561199
movdqa 0x50(%rsp), %xmm0
punpckhqdq %xmm0, %xmm0 # xmm0 = xmm0[1,1]
movdqa %xmm0, 0x30(%rsp)
movq 0x8(%rsp), %r12
movq 0x60(%rsp), %rbp
movq %r15, 0x10(%rsp)
movl $0x400, %eax # imm = 0x400
cmpl %eax, %r15d
movl $0x400, %ebx # imm = 0x400
cmovll %r15d, %ebx
subq $0x8, %rsp
leaq 0x30f8(%rsp), %r13
movq %r13, %rdi
leaq 0x10f8(%rsp), %r15
movq %r15, %rsi
leaq 0x8f8(%rsp), %rdx
leaq 0xf8(%rsp), %rcx
movl %ebx, %r8d
movq 0x30(%rsp), %r9
movdqa 0x58(%rsp), %xmm0
movdqa 0x38(%rsp), %xmm1
movq 0x48(%rsp), %xmm2
leaq 0xe0(%rsp), %rax
pushq %rax
leaq 0xf0(%rsp), %rax
pushq %rax
leaq 0x100(%rsp), %rax
pushq %rax
callq 0x562e3d
addq $0x20, %rsp
leal (%rbx,%rbx), %r14d
movq %r13, %rdi
movl %r14d, %esi
movq %rbp, %rdx
movq 0x68(%rsp), %r13
callq *0x10(%r13)
movq %r15, %rdi
movq 0x10(%rsp), %r15
movl %r14d, %esi
movq %rbp, %rdx
callq *0x10(%r13)
xorpd %xmm3, %xmm3
testl %r15d, %r15d
jle 0x561189
movl %ebx, %eax
xorl %ecx, %ecx
movzwl 0x8f0(%rsp,%rcx,2), %edx
shrl $0x8, %edx
movzbl 0xf1(%rsp,%rcx,2), %esi
movq 0x30f0(%rsp,%rcx,8), %xmm0
movq 0x10f0(%rsp,%rcx,8), %xmm1
punpcklbw %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1],xmm0[2],xmm3[2],xmm0[3],xmm3[3],xmm0[4],xmm3[4],xmm0[5],xmm3[5],xmm0[6],xmm3[6],xmm0[7],xmm3[7]
punpcklbw %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1],xmm1[2],xmm3[2],xmm1[3],xmm3[3],xmm1[4],xmm3[4],xmm1[5],xmm3[5],xmm1[6],xmm3[6],xmm1[7],xmm3[7]
movl $0x100, %edi # imm = 0x100
subl %esi, %edi
movd %edi, %xmm2
pshuflw $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
pmullw %xmm0, %xmm2
movd %esi, %xmm0
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
pmullw %xmm1, %xmm0
paddw %xmm2, %xmm0
movl $0x100, %esi # imm = 0x100
subl %edx, %esi
movd %esi, %xmm1
movd %edx, %xmm2
punpcklwd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
pshufd $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,1,3]
pshuflw $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,1,3,4,5,6,7]
pshufhw $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2,3,4,6,5,7]
psrlw $0x8, %xmm0
pmaddwd %xmm1, %xmm0
psrld $0x8, %xmm0
packssdw %xmm0, %xmm0
packuswb %xmm0, %xmm0
movd %xmm0, (%r12,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x5610de
movslq %ebx, %rax
leaq (%r12,%rax,4), %r12
subl %ebx, %r15d
jne 0x561027
movq %fs:0x28, %rax
cmpq 0x50f0(%rsp), %rax
jne 0x5615e3
movq 0x8(%rsp), %rax
addq $0x50f8, %rsp # imm = 0x50F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cvttpd2dq 0x10(%rsp), %xmm4
pshufd $0x55, %xmm4, %xmm0 # xmm0 = xmm4[1,1,1,1]
movd %xmm0, %eax
cvttpd2dq %xmm2, %xmm3
paddd 0x6d0ae(%rip), %xmm3 # 0x5ce290
movd %xmm3, 0x8f0(%rsp)
movq %rax, 0x50(%rsp)
testl %eax, %eax
je 0x561376
testl %r15d, %r15d
je 0x561199
movd %xmm4, %eax
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rbp
movaps %xmm4, 0x30(%rsp)
movq 0x60(%rsp), %r13
movl $0x400, %eax # imm = 0x400
cmpl %eax, %r15d
movl $0x400, %ebx # imm = 0x400
cmovll %r15d, %ebx
movd %xmm3, %r8d
movdqa %xmm3, 0x10(%rsp)
pshufd $0x55, %xmm3, %xmm0 # xmm0 = xmm3[1,1,1,1]
movd %xmm0, %r9d
leaq 0x30f0(%rsp), %r12
movq %r12, %rdi
leaq 0x10f0(%rsp), %rsi
movl %ebx, %edx
movq 0x28(%rsp), %rcx
pushq 0x50(%rsp)
pushq 0x48(%rsp)
callq 0x562be6
addq $0x10, %rsp
leal (%rbx,%rbx), %r14d
movq %r12, %rdi
movl %r14d, %esi
movq %r13, %rdx
movq 0x68(%rsp), %r12
callq *0x10(%r12)
leaq 0x10f0(%rsp), %rdi
movl %r14d, %esi
movq %r13, %rdx
callq *0x10(%r12)
testl %r15d, %r15d
jle 0x56135a
movl %ebx, %eax
xorl %ecx, %ecx
movdqa 0x10(%rsp), %xmm3
movdqa 0x30(%rsp), %xmm4
pxor %xmm5, %xmm5
movd %xmm3, %edx
movzbl %dh, %edx
movq 0x30f0(%rsp,%rcx,8), %xmm0
movq 0x10f0(%rsp,%rcx,8), %xmm1
punpcklbw %xmm5, %xmm0 # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1],xmm0[2],xmm5[2],xmm0[3],xmm5[3],xmm0[4],xmm5[4],xmm0[5],xmm5[5],xmm0[6],xmm5[6],xmm0[7],xmm5[7]
punpcklbw %xmm5, %xmm1 # xmm1 = xmm1[0],xmm5[0],xmm1[1],xmm5[1],xmm1[2],xmm5[2],xmm1[3],xmm5[3],xmm1[4],xmm5[4],xmm1[5],xmm5[5],xmm1[6],xmm5[6],xmm1[7],xmm5[7]
pextrw $0x2, %xmm3, %esi
shrl $0x8, %esi
movl $0x100, %edi # imm = 0x100
subl %esi, %edi
movd %edi, %xmm2
pshuflw $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
pmullw %xmm0, %xmm2
movd %esi, %xmm0
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
pmullw %xmm1, %xmm0
paddw %xmm2, %xmm0
movl $0x100, %esi # imm = 0x100
subl %edx, %esi
movd %esi, %xmm1
movd %edx, %xmm2
punpcklwd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
pshufd $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
pshufd $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,1,3]
pshuflw $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,1,3,4,5,6,7]
pshufhw $0xd8, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2,3,4,6,5,7]
psrlw $0x8, %xmm0
pmaddwd %xmm1, %xmm0
psrld $0x8, %xmm0
packssdw %xmm0, %xmm0
packuswb %xmm0, %xmm0
movd %xmm0, (%rbp,%rcx,4)
paddd %xmm4, %xmm3
incq %rcx
cmpq %rcx, %rax
jne 0x5612ad
jmp 0x561360
movdqa 0x10(%rsp), %xmm3
movslq %ebx, %rax
leaq (%rbp,%rax,4), %rbp
subl %ebx, %r15d
jne 0x561215
jmp 0x561199
movslq %r15d, %r12
movd %xmm4, %r13d
movl %r13d, %eax
negl %eax
cmovsl %r13d, %eax
cmpl $0x10000, %eax # imm = 0x10000
ja 0x5613bb
movq 0x8(%rsp), %rdi
leaq (%rdi,%r12,4), %rsi
pshufd $0x55, %xmm3, %xmm0 # xmm0 = xmm3[1,1,1,1]
movd %xmm0, %r8d
leaq 0x8f0(%rsp), %rcx
movq 0x28(%rsp), %rdx
movl %r13d, %r9d
callq 0x55e543
jmp 0x561199
cmpl $0x20000, %eax # imm = 0x20000
ja 0x561433
leal 0x1(%r15), %eax
shrl %eax
cmpl $0x400, %r15d # imm = 0x400
cmovll %r15d, %eax
movslq %eax, %rbp
movq 0x8(%rsp), %rdi
leaq (%rdi,%rbp,4), %r14
pshufd $0x55, %xmm3, %xmm0 # xmm0 = xmm3[1,1,1,1]
movd %xmm0, %r8d
leaq 0x8f0(%rsp), %rcx
movq %r14, %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdx
movl %r8d, 0x10(%rsp)
movl %r13d, %r9d
callq 0x55e543
cmpl %r15d, %ebp
je 0x561199
movq 0x8(%rsp), %rax
leaq (%rax,%r12,4), %rsi
leaq 0x8f0(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
movl 0x10(%rsp), %r8d
jmp 0x5613ae
testl %r15d, %r15d
je 0x561199
movd %xmm3, %eax
pshufd $0x55, %xmm3, %xmm0 # xmm0 = xmm3[1,1,1,1]
movd %xmm0, %ecx
movl %ecx, 0x50(%rsp)
movzbl %ch, %ecx
movl $0x100, %edx # imm = 0x100
subl %ecx, %edx
movd %edx, %xmm1
pshuflw $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm3 # xmm3 = xmm1[0,0,0,0]
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm4 # xmm4 = xmm0[0,0,0,0]
psrlw $0x8, %xmm4
movq 0x8(%rsp), %r12
movdqa %xmm3, 0x40(%rsp)
movdqa %xmm4, 0x30(%rsp)
movq 0x60(%rsp), %rbp
movl $0x400, %ecx # imm = 0x400
cmpl %ecx, %r15d
movl $0x400, %ebx # imm = 0x400
cmovll %r15d, %ebx
leaq 0x30f0(%rsp), %r14
movq %r14, %rdi
leaq 0x10f0(%rsp), %rsi
movl %ebx, %edx
movq 0x28(%rsp), %rcx
movl %eax, %r8d
movl 0x50(%rsp), %r9d
pushq $0x0
pushq %r13
callq 0x562be6
addq $0x10, %rsp
leal (%rbx,%rbx), %esi
movl %esi, 0x10(%rsp)
movq %r14, %rdi
movq %rbp, %rdx
movq 0x68(%rsp), %r14
callq *0x10(%r14)
leaq 0x10f0(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rbp, %rdx
callq *0x10(%r14)
movl 0x8f0(%rsp), %eax
testl %r15d, %r15d
jle 0x56158e
movl %ebx, %ecx
xorl %edx, %edx
movdqa 0x40(%rsp), %xmm3
movdqa 0x30(%rsp), %xmm4
pxor %xmm5, %xmm5
movzbl %ah, %esi
movq 0x30f0(%rsp,%rdx,8), %xmm0
movq 0x10f0(%rsp,%rdx,8), %xmm1
punpcklbw %xmm5, %xmm0 # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1],xmm0[2],xmm5[2],xmm0[3],xmm5[3],xmm0[4],xmm5[4],xmm0[5],xmm5[5],xmm0[6],xmm5[6],xmm0[7],xmm5[7]
pmullw %xmm3, %xmm0
punpcklbw %xmm5, %xmm1 # xmm1 = xmm1[0],xmm5[0],xmm1[1],xmm5[1],xmm1[2],xmm5[2],xmm1[3],xmm5[3],xmm1[4],xmm5[4],xmm1[5],xmm5[5],xmm1[6],xmm5[6],xmm1[7],xmm5[7]
pmullw %xmm4, %xmm1
paddw %xmm0, %xmm1
movl $0x100, %edi # imm = 0x100
subl %esi, %edi
movd %edi, %xmm0
movd %esi, %xmm2
punpcklwd %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1],xmm0[2],xmm2[2],xmm0[3],xmm2[3]
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
pshufd $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,2,1,3]
pshuflw $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,2,1,3,4,5,6,7]
pshufhw $0xd8, %xmm1, %xmm1 # xmm1 = xmm1[0,1,2,3,4,6,5,7]
psrlw $0x8, %xmm1
pmaddwd %xmm0, %xmm1
psrld $0x8, %xmm1
packssdw %xmm1, %xmm1
packuswb %xmm1, %xmm1
movd %xmm1, (%r12,%rdx,4)
addl %r13d, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x561517
movl %eax, 0x8f0(%rsp)
movslq %ebx, %rcx
leaq (%r12,%rcx,4), %r12
subl %ebx, %r15d
jne 0x56148a
jmp 0x561199
movupd 0x38(%r13), %xmm2
movupd 0x50(%r13), %xmm0
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
movapd %xmm2, 0x50(%rsp)
mulpd %xmm2, %xmm1
movapd %xmm4, %xmm2
unpcklpd %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
movhpd 0x78(%r13), %xmm5 # xmm5 = xmm5[0],mem[0]
addpd %xmm2, %xmm5
jmp 0x560fc0
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_fetcher<(TextureBlendType)5, (QPixelLayout::BPP)7, QRgba64>(QRgba64*, QRgba64*, int, QTextureData const&, int, int, int, int) | static void QT_FASTCALL fetchTransformedBilinear_fetcher(T *buf1, T *buf2, const int len, const QTextureData &image,
int fx, int fy, const int fdx, const int fdy)
{
const QPixelLayout &layout = qPixelLayouts[image.format];
constexpr bool useFetch = (bpp < QPixelLayout::BPP32);
if (useFetch)
Q_ASSERT(sizeof(T) == sizeof(uint));
else
Q_ASSERT(layout.bpp == bpp || (layout.bpp == QPixelLayout::BPP16FPx4 && bpp == QPixelLayout::BPP64));
const Fetch1PixelFunc fetch1 = (bpp == QPixelLayout::BPPNone) ? fetch1PixelTable[layout.bpp] : fetch1Pixel<bpp>;
if (fdy == 0) {
int y1 = (fy >> 16);
int y2;
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
const uchar *s1 = image.scanLine(y1);
const uchar *s2 = image.scanLine(y2);
int i = 0;
if (blendType == BlendTransformedBilinear) {
for (; i < len; ++i) {
int x1 = (fx >> 16);
int x2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
if (x1 != x2)
break;
if constexpr (useFetch) {
buf1[i * 2 + 0] = buf1[i * 2 + 1] = fetch1(s1, x1);
buf2[i * 2 + 0] = buf2[i * 2 + 1] = fetch1(s2, x1);
} else {
buf1[i * 2 + 0] = buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x1];
buf2[i * 2 + 0] = buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x1];
}
fx += fdx;
}
int fastLen = len;
if (fdx > 0)
fastLen = qMin(fastLen, int((qint64(image.x2 - 1) * fixed_scale - fx) / fdx));
else if (fdx < 0)
fastLen = qMin(fastLen, int((qint64(image.x1) * fixed_scale - fx) / fdx));
for (; i < fastLen; ++i) {
int x = (fx >> 16);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x);
buf1[i * 2 + 1] = fetch1(s1, x + 1);
buf2[i * 2 + 0] = fetch1(s2, x);
buf2[i * 2 + 1] = fetch1(s2, x + 1);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x + 1];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x + 1];
}
fx += fdx;
}
}
for (; i < len; ++i) {
int x1 = (fx >> 16);
int x2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x1);
buf1[i * 2 + 1] = fetch1(s1, x2);
buf2[i * 2 + 0] = fetch1(s2, x1);
buf2[i * 2 + 1] = fetch1(s2, x2);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x1];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x2];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x1];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x2];
}
fx += fdx;
}
} else {
int i = 0;
if (blendType == BlendTransformedBilinear) {
for (; i < len; ++i) {
int x1 = (fx >> 16);
int x2;
int y1 = (fy >> 16);
int y2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
if (x1 != x2 && y1 != y2)
break;
const uchar *s1 = image.scanLine(y1);
const uchar *s2 = image.scanLine(y2);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x1);
buf1[i * 2 + 1] = fetch1(s1, x2);
buf2[i * 2 + 0] = fetch1(s2, x1);
buf2[i * 2 + 1] = fetch1(s2, x2);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x1];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x2];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x1];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x2];
}
fx += fdx;
fy += fdy;
}
int fastLen = len;
if (fdx > 0)
fastLen = qMin(fastLen, int((qint64(image.x2 - 1) * fixed_scale - fx) / fdx));
else if (fdx < 0)
fastLen = qMin(fastLen, int((qint64(image.x1) * fixed_scale - fx) / fdx));
if (fdy > 0)
fastLen = qMin(fastLen, int((qint64(image.y2 - 1) * fixed_scale - fy) / fdy));
else if (fdy < 0)
fastLen = qMin(fastLen, int((qint64(image.y1) * fixed_scale - fy) / fdy));
for (; i < fastLen; ++i) {
int x = (fx >> 16);
int y = (fy >> 16);
const uchar *s1 = image.scanLine(y);
const uchar *s2 = s1 + image.bytesPerLine;
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x);
buf1[i * 2 + 1] = fetch1(s1, x + 1);
buf2[i * 2 + 0] = fetch1(s2, x);
buf2[i * 2 + 1] = fetch1(s2, x + 1);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x + 1];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x + 1];
}
fx += fdx;
fy += fdy;
}
}
for (; i < len; ++i) {
int x1 = (fx >> 16);
int x2;
int y1 = (fy >> 16);
int y2;
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
const uchar *s1 = image.scanLine(y1);
const uchar *s2 = image.scanLine(y2);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x1);
buf1[i * 2 + 1] = fetch1(s1, x2);
buf2[i * 2 + 0] = fetch1(s2, x1);
buf2[i * 2 + 1] = fetch1(s2, x2);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x1];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x2];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x1];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x2];
}
fx += fdx;
fy += fdy;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r10d
movq %rsi, -0x10(%rsp)
movl 0x40(%rsp), %r12d
movl 0x38(%rsp), %r13d
testl %r12d, %r12d
je 0x567d48
testl %r10d, %r10d
movq %rcx, -0x18(%rsp)
jle 0x567dfa
movq -0x18(%rsp), %rax
movl 0x8(%rax), %ebp
movl 0xc(%rax), %r14d
movq (%rax), %rsi
movl %r10d, %eax
shlq $0x4, %rax
movq %rax, -0x8(%rsp)
xorl %r11d, %r11d
movl %r8d, %eax
sarl $0x10, %eax
movl %r9d, %r10d
sarl $0x10, %r10d
cltd
idivl %ebp
movl %edx, %eax
sarl $0x1f, %eax
andl %ebp, %eax
leal (%rax,%rdx), %ebx
movl %r13d, %ecx
leal (%rax,%rdx), %r13d
incl %r13d
cmpl %ebp, %r13d
movl $0x0, %r15d
cmovel %r15d, %r13d
movl %r10d, %eax
cltd
idivl %r14d
movl %edx, %eax
sarl $0x1f, %eax
andl %r14d, %eax
leal (%rax,%rdx), %r10d
addl %edx, %eax
incl %eax
cmpl %r14d, %eax
cmovel %r15d, %eax
movq -0x10(%rsp), %r15
movslq %r10d, %rdx
movq -0x18(%rsp), %r10
movq 0x20(%r10), %r10
imulq %r10, %rdx
addq %rsi, %rdx
cltq
imulq %r10, %rax
movslq %ebx, %r10
movq (%rdx,%r10,8), %rbx
movq %rbx, (%rdi,%r11)
movslq %r13d, %rbx
movl %ecx, %r13d
movq (%rdx,%rbx,8), %rdx
movq %rdx, 0x8(%rdi,%r11)
addq %rsi, %rax
movq (%rax,%r10,8), %rdx
movq %rdx, (%r15,%r11)
movq (%rax,%rbx,8), %rax
movq %rax, 0x8(%r15,%r11)
addl %ecx, %r8d
addl %r12d, %r9d
addq $0x10, %r11
cmpq %r11, -0x8(%rsp)
jne 0x567c93
jmp 0x567dfa
sarl $0x10, %r9d
movl 0xc(%rcx), %r11d
movl %r9d, %eax
cltd
idivl %r11d
movl %edx, %eax
sarl $0x1f, %eax
andl %r11d, %eax
movq %rcx, %r14
leal (%rax,%rdx), %ecx
incl %ecx
xorl %r9d, %r9d
cmpl %r11d, %ecx
cmovel %r9d, %ecx
testl %r10d, %r10d
jle 0x567dfa
addl %edx, %eax
movq (%r14), %rdx
movslq %eax, %r11
movq 0x20(%r14), %rax
imulq %rax, %r11
addq %rdx, %r11
movslq %ecx, %rbx
imulq %rax, %rbx
addq %rdx, %rbx
movl 0x8(%r14), %ecx
movl %r10d, %r10d
shlq $0x4, %r10
xorl %r14d, %r14d
movq -0x10(%rsp), %rsi
movl %r8d, %eax
sarl $0x10, %eax
cltd
idivl %ecx
movl %edx, %eax
sarl $0x1f, %eax
andl %ecx, %eax
leal (%rax,%rdx), %ebp
addl %edx, %eax
incl %eax
cmpl %ecx, %eax
cmovel %r9d, %eax
movslq %ebp, %rdx
movq (%r11,%rdx,8), %r15
movq %r15, (%rdi,%r14)
cltq
movq (%r11,%rax,8), %r15
movq %r15, 0x8(%rdi,%r14)
movq (%rbx,%rdx,8), %rdx
movq %rdx, (%rsi,%r14)
movq (%rbx,%rax,8), %rax
movq %rax, 0x8(%rsi,%r14)
addl %r13d, %r8d
addq $0x10, %r14
cmpq %r14, %r10
jne 0x567daa
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_slow_fetcher<(TextureBlendType)5, (QPixelLayout::BPP)9, QRgbaFloat<float>>(QRgbaFloat<float>*, QRgbaFloat<float>*, unsigned short*, unsigned short*, int, QTextureData const&, double&, double&, double&, double, double, double) | static void QT_FASTCALL fetchTransformedBilinear_slow_fetcher(T *buf1, T *buf2, ushort *distxs, ushort *distys,
const int len, const QTextureData &image,
qreal &fx, qreal &fy, qreal &fw,
const qreal fdx, const qreal fdy, const qreal fdw)
{
const QPixelLayout &layout = qPixelLayouts[image.format];
constexpr bool useFetch = (bpp < QPixelLayout::BPP32);
if (useFetch)
Q_ASSERT(sizeof(T) == sizeof(uint));
else
Q_ASSERT(layout.bpp == bpp);
const Fetch1PixelFunc fetch1 = (bpp == QPixelLayout::BPPNone) ? fetch1PixelTable[layout.bpp] : fetch1Pixel<bpp>;
for (int i = 0; i < len; ++i) {
const qreal iw = fw == 0 ? 16384 : 1 / fw;
const qreal px = fx * iw - qreal(0.5);
const qreal py = fy * iw - qreal(0.5);
int x1 = qFloor(px);
int x2;
int y1 = qFloor(py);
int y2;
distxs[i] = ushort((px - x1) * (1<<16));
distys[i] = ushort((py - y1) * (1<<16));
fetchTransformedBilinear_pixelBounds<blendType>(image.width, image.x1, image.x2 - 1, x1, x2);
fetchTransformedBilinear_pixelBounds<blendType>(image.height, image.y1, image.y2 - 1, y1, y2);
const uchar *s1 = image.scanLine(y1);
const uchar *s2 = image.scanLine(y2);
if constexpr (useFetch) {
buf1[i * 2 + 0] = fetch1(s1, x1);
buf1[i * 2 + 1] = fetch1(s1, x2);
buf2[i * 2 + 0] = fetch1(s2, x1);
buf2[i * 2 + 1] = fetch1(s2, x2);
} else {
buf1[i * 2 + 0] = reinterpret_cast<const T *>(s1)[x1];
buf1[i * 2 + 1] = reinterpret_cast<const T *>(s1)[x2];
buf2[i * 2 + 0] = reinterpret_cast<const T *>(s2)[x1];
buf2[i * 2 + 1] = reinterpret_cast<const T *>(s2)[x2];
}
fx += fdx;
fy += fdy;
fw += fdw;
}
} | testl %r8d, %r8d
jle 0x56820f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq 0xb0(%rsp), %rax
movl %r8d, %edx
movq %rdx, 0x8(%rsp)
movsd (%rax), %xmm4
movl $0x8, %r15d
xorl %r14d, %r14d
movsd %xmm2, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movsd 0xc72d(%rip), %xmm0 # 0x574760
divsd %xmm4, %xmm0
cmpeqsd 0x1a3e8(%rip), %xmm4 # 0x582428
movapd %xmm4, %xmm1
andnpd %xmm0, %xmm1
movsd 0x66290(%rip), %xmm0 # 0x5ce2e0
andpd %xmm0, %xmm4
orpd %xmm1, %xmm4
movq 0xa0(%rsp), %rax
movsd (%rax), %xmm1
mulsd %xmm4, %xmm1
movsd 0x3abc0(%rip), %xmm0 # 0x5a2c30
addsd %xmm0, %xmm1
movsd %xmm1, 0x38(%rsp)
movq 0xa8(%rsp), %rax
mulsd (%rax), %xmm4
addsd %xmm0, %xmm4
movapd %xmm4, 0x40(%rsp)
movapd %xmm1, %xmm0
movq %r9, %rbx
callq 0x138490
movapd %xmm0, 0x50(%rsp)
cvttsd2si %xmm0, %ebp
movapd 0x40(%rsp), %xmm0
callq 0x138490
movq %rbx, %r9
movsd 0x20(%rsp), %xmm3
cvttpd2dq 0x50(%rsp), %xmm1
cvttpd2dq %xmm0, %xmm2
cvtdq2pd %xmm1, %xmm1
movsd 0x38(%rsp), %xmm5
subsd %xmm1, %xmm5
cvtdq2pd %xmm2, %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0xde2c(%rip), %xmm4 # 0x575f10
mulsd %xmm4, %xmm5
movapd 0x40(%rsp), %xmm6
subsd %xmm1, %xmm6
movsd 0x28(%rsp), %xmm1
mulsd %xmm4, %xmm6
cvttsd2si %xmm5, %eax
cvttsd2si %xmm6, %edx
cvttsd2si %xmm0, %edi
movw %ax, (%r13,%r14,2)
movw %dx, (%r12,%r14,2)
movl 0x8(%rbx), %r8d
movl %ebp, %eax
cltd
idivl %r8d
movl %edx, %eax
sarl $0x1f, %eax
andl %r8d, %eax
leal (%rax,%rdx), %r11d
leal (%rax,%rdx), %esi
incl %esi
cmpl %r8d, %esi
movl 0xc(%rbx), %r8d
movl $0x0, %ebx
cmovel %ebx, %esi
movl %edi, %eax
cltd
idivl %r8d
movl %edx, %eax
sarl $0x1f, %eax
andl %r8d, %eax
leal (%rax,%rdx), %edi
addl %edx, %eax
incl %eax
cmpl %r8d, %eax
cmovel %ebx, %eax
movslq %edi, %r8
movq 0x10(%rsp), %rdi
movq 0x20(%r9), %rdx
imulq %rdx, %r8
cltq
imulq %rdx, %rax
movq (%r9), %rdx
addq %rdx, %r8
addq %rdx, %rax
movslq %r11d, %rdx
shlq $0x4, %rdx
movaps (%rdx,%r8), %xmm0
movaps %xmm0, -0x10(%rdi,%r15,2)
movslq %esi, %r11
shlq $0x4, %r11
movaps (%r11,%r8), %xmm0
movaps %xmm0, (%rdi,%r15,2)
movaps (%rdx,%rax), %xmm0
movq 0x18(%rsp), %rsi
movaps %xmm0, -0x10(%rsi,%r15,2)
movaps (%r11,%rax), %xmm0
movaps %xmm0, (%rsi,%r15,2)
movq 0xa0(%rsp), %rax
movsd (%rax), %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, (%rax)
movq 0xa8(%rsp), %rax
movsd (%rax), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq 0xb0(%rsp), %rax
movsd (%rax), %xmm4
addsd %xmm2, %xmm4
movsd %xmm4, (%rax)
incq %r14
addq $0x10, %r15
cmpq %r14, 0x8(%rsp)
jne 0x56802b
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
convertRGBA64PMToRGBA32F(QRgbaFloat<float>*, unsigned long long const*, int) | static void QT_FASTCALL convertRGBA64PMToRGBA32F(QRgbaFloat32 *buffer, const quint64 *src, int count)
{
const auto *in = reinterpret_cast<const QRgba64 *>(src);
for (int i = 0; i < count; ++i) {
auto c = in[i];
buffer[i] = QRgbaFloat32::fromRgba64(c.red(), c.green(), c.blue(), c.alpha()).premultiplied();
}
} | endbr64
testl %edx, %edx
jle 0x56b845
movl %edx, %eax
shlq $0x3, %rax
xorl %ecx, %ecx
movl $0xffff, %edx # imm = 0xFFFF
movss 0x2d167(%rip), %xmm0 # 0x598940
movaps 0x2df50(%rip), %xmm1 # 0x599730
movq (%rsi,%rcx), %r8
movl %r8d, %r9d
shrl $0x10, %r9d
movq %r8, %r10
shrq $0x20, %r10
movq %r8, %r11
shrq $0x30, %r11
andl %edx, %r10d
xorps %xmm2, %xmm2
cvtsi2ss %r10d, %xmm2
mulss %xmm0, %xmm2
xorps %xmm3, %xmm3
cvtsi2ss %r11d, %xmm3
andl %edx, %r8d
movd %r8d, %xmm4
pinsrw $0x2, %r9d, %xmm4
mulss %xmm0, %xmm3
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
mulss %xmm3, %xmm2
unpcklps %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
unpcklps %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1]
mulps %xmm4, %xmm3
movlhps %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
movaps %xmm3, (%rdi,%rcx,2)
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x56b7e0
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
destStoreMonoLsb(QRasterBuffer*, int, int, unsigned int const*, int) | static void QT_FASTCALL destStoreMonoLsb(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
{
uchar *Q_DECL_RESTRICT data = (uchar *)rasterBuffer->scanLine(y);
if (rasterBuffer->monoDestinationWithClut) {
for (int i = 0; i < length; ++i) {
if (buffer[i] == rasterBuffer->destColor0) {
data[x >> 3] &= ~(1 << (x & 7));
} else if (buffer[i] == rasterBuffer->destColor1) {
data[x >> 3] |= 1 << (x & 7);
} else if (findNearestColor(buffer[i], rasterBuffer) == rasterBuffer->destColor0) {
data[x >> 3] &= ~(1 << (x & 7));
} else {
data[x >> 3] |= 1 << (x & 7);
}
++x;
}
} else {
for (int i = 0; i < length; ++i) {
if (qGray(buffer[i]) < int(qt_bayer_matrix[y & 15][x & 15]))
data[x >> 3] |= 1 << (x & 7);
else
data[x >> 3] &= ~(1 << (x & 7));
++x;
}
}
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rax
movslq %edx, %r9
imulq 0x28(%rdi), %r9
addq 0x38(%rdi), %r9
cmpb $0x0, (%rdi)
je 0x56bf69
testl %r8d, %r8d
jle 0x56bffc
movl %r8d, %edx
movl %esi, %esi
xorl %r8d, %r8d
movq %rdx, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
leaq (%rsi,%r8), %r15
movl (%rax,%r8,4), %r11d
movl 0x4(%rdi), %r13d
cmpl %r13d, %r11d
jne 0x56be6b
movl %r15d, %ecx
andb $0x7, %cl
movl $0x1, %r10d
shll %cl, %r10d
sarl $0x3, %r15d
movslq %r15d, %rcx
notb %r10b
andb %r10b, (%r9,%rcx)
jmp 0x56bf58
movl 0x8(%rdi), %r14d
movl %r15d, %ecx
andb $0x7, %cl
cmpl %r14d, %r11d
jne 0x56be93
movl $0x1, %r10d
shll %cl, %r10d
sarl $0x3, %r15d
movslq %r15d, %rcx
orb %r10b, (%r9,%rcx)
jmp 0x56bf58
movl $0x1, %ebx
shll %cl, %ebx
sarl $0x3, %r15d
movslq %r15d, %rcx
movb (%r9,%rcx), %bpl
cmpl %r13d, %r14d
je 0x56bf4f
movl %r11d, %edx
shrl $0x10, %edx
movq %rcx, -0x8(%rsp)
movl $0xff, %ecx
andl %ecx, %edx
movl %r11d, %esi
shrl $0x8, %esi
andl %ecx, %esi
andl %ecx, %r11d
movl %r13d, %r10d
shrl $0x10, %r10d
andl %ecx, %r10d
movl %edx, %r15d
subl %r10d, %r15d
movl %r13d, %r10d
shrl $0x8, %r10d
andl %ecx, %r10d
movl %esi, %r12d
subl %r10d, %r12d
andl %ecx, %r13d
movl %r11d, %r10d
subl %r13d, %r10d
imull %r15d, %r15d
imull %r12d, %r12d
imull %r10d, %r10d
addl %r12d, %r10d
addl %r15d, %r10d
movl %r14d, %r15d
shrl $0x10, %r15d
andl %ecx, %r15d
subl %r15d, %edx
movl %r14d, %r15d
shrl $0x8, %r15d
andl %ecx, %r15d
subl %r15d, %esi
andl %ecx, %r14d
movq -0x8(%rsp), %rcx
subl %r14d, %r11d
imull %edx, %edx
imull %esi, %esi
imull %r11d, %r11d
addl %esi, %r11d
movq -0x18(%rsp), %rsi
addl %edx, %r11d
movq -0x10(%rsp), %rdx
cmpl %r11d, %r10d
jb 0x56bf4f
orb %bl, %bpl
jmp 0x56bf54
notb %bl
andb %bl, %bpl
movb %bpl, (%r9,%rcx)
incq %r8
cmpq %r8, %rdx
jne 0x56be38
jmp 0x56bffc
testl %r8d, %r8d
jle 0x56bffc
andl $0xf, %edx
movl %r8d, %edi
movl %esi, %esi
xorl %r8d, %r8d
movl $0xff, %r10d
shll $0x6, %edx
leaq 0x62473(%rip), %r11 # 0x5ce400
addq %rdx, %r11
leal (%rsi,%r8), %edx
movl (%rax,%r8,4), %ecx
movl %ecx, %ebx
shrl $0x10, %ebx
andl %r10d, %ebx
movl %ecx, %r14d
andl %r10d, %r14d
leal (%rbx,%rbx,4), %r15d
leal (%rbx,%r15,2), %ebx
shrl $0x4, %ecx
andl $0xff0, %ecx # imm = 0xFF0
leal (%r14,%r14,4), %ebp
addl %ecx, %ebp
addl %ebx, %ebp
shrl $0x5, %ebp
movl %edx, %r14d
andl $0xf, %r14d
movl %edx, %ecx
andb $0x7, %cl
movl $0x1, %ebx
shll %cl, %ebx
sarl $0x3, %edx
movslq %edx, %rcx
movb (%r9,%rcx), %dl
cmpl (%r11,%r14,4), %ebp
jl 0x56bfeb
notb %bl
andb %bl, %dl
jmp 0x56bfed
orb %bl, %dl
movzbl %dl, %edx
movb %dl, (%r9,%rcx)
incq %r8
cmpq %r8, %rdi
jne 0x56bf90
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
destStoreGray8(QRasterBuffer*, int, int, unsigned int const*, int) | static void QT_FASTCALL destStoreGray8(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
{
uchar *data = rasterBuffer->scanLine(y) + x;
bool failed = false;
for (int k = 0; k < length; ++k) {
if (!qIsGray(buffer[k])) {
failed = true;
break;
}
data[k] = qRed(buffer[k]);
}
if (failed) { // Non-gray colors
QColorSpace fromCS = rasterBuffer->colorSpace.isValid() ? rasterBuffer->colorSpace : QColorSpace::SRgb;
QColorTransform tf = QColorSpacePrivate::get(fromCS)->transformationToXYZ();
QColorTransformPrivate *tfd = QColorTransformPrivate::get(tf);
tfd->apply(data, buffer, length, QColorTransformPrivate::InputPremultiplied);
}
} | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
testl %r8d, %r8d
jle 0x56c1a0
movq %rcx, %rbx
movq %rdi, %r12
movslq %edx, %rax
imulq 0x28(%rdi), %rax
addq 0x38(%rdi), %rax
movslq %esi, %r14
addq %rax, %r14
movl %r8d, %r15d
xorl %eax, %eax
movl $0xff, %ecx
movl (%rbx,%rax,4), %esi
movl %esi, %edx
shrl $0x10, %edx
movl %edx, %edi
andl %ecx, %edi
movl %esi, %r8d
shrl $0x8, %r8d
andl %ecx, %r8d
cmpl %r8d, %edi
jne 0x56c126
andl %ecx, %esi
cmpl %esi, %edi
jne 0x56c126
movb %dl, (%r14,%rax)
incq %rax
cmpq %rax, %r15
jne 0x56c0f7
jmp 0x56c1a0
movabsq $-0x5555555555555556, %r13 # imm = 0xAAAAAAAAAAAAAAAA
movq %r13, 0x10(%rsp)
addq $0x18, %r12
movq %r12, %rdi
callq 0x1442d0
leaq 0x10(%rsp), %rdi
testb %al, %al
je 0x56c154
movq %r12, %rsi
callq 0x13c350
jmp 0x56c15e
movl $0x1, %esi
callq 0x140270
leaq 0x8(%rsp), %r12
movq %r13, (%r12)
leaq 0x10(%rsp), %r13
movq (%r13), %rsi
movq %r12, %rdi
callq 0x263bde
movq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movl $0x2, %r8d
callq 0x26be64
movq %r12, %rdi
callq 0x139960
movq %r13, %rdi
callq 0x137710
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x56c1be
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
QRunnable::QGenericRunnable::Helper<blend_tiled_argb(int, QT_FT_Span_ const*, void*)::$_0>::impl(QRunnable::QGenericRunnable::HelperBase::Op, QRunnable::QGenericRunnable::HelperBase*, void*) | static void *impl(Op op, HelperBase *that, [[maybe_unused]] void *arg)
{
const auto _this = static_cast<Helper*>(that);
switch (op) {
case Op::Run: _this->object()(); break;
case Op::Destroy: delete _this; break;
}
return nullptr;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
cmpl $0x1, %edi
je 0x56ccf3
testl %edi, %edi
jne 0x56cd00
movq %rax, 0x10(%rsp)
movl 0xc(%rax), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
jle 0x56ccde
movq 0x10(%rsp), %rax
movq 0x10(%rax), %r12
movslq 0x8(%rax), %rcx
addl %ecx, 0x8(%rsp)
movl $0x800, %edi # imm = 0x800
movq (%r12), %rax
movq %rcx, 0x20(%rsp)
shlq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movl 0x4(%rax,%rcx), %r15d
testl %r15d, %r15d
je 0x56cccc
movq 0x18(%rsp), %rcx
movzbl 0xc(%rax,%rcx), %edx
imull 0x18(%r12), %edx
sarl $0x8, %edx
movl %edx, 0xc(%rsp)
movl (%rax,%rcx), %ebx
movl 0x8(%rax,%rcx), %eax
addl 0x10(%r12), %eax
movl 0xc(%r12), %r14d
movl 0x14(%r12), %ecx
cltd
idivl %ecx
movl %edx, %esi
sarl $0x1f, %esi
andl %ecx, %esi
addl %edx, %esi
movl 0x8(%r12), %eax
addl %ebx, %eax
cltd
idivl %r14d
movl %edx, %ebp
sarl $0x1f, %ebp
andl %r14d, %ebp
addl %edx, %ebp
movslq %esi, %r13
subl %ebp, %r14d
cmpl %r15d, %r14d
cmovgel %r15d, %r14d
cmpl %edi, %r14d
cmovgel %edi, %r14d
movq (%r12), %rax
movq 0x20(%r12), %rcx
movq 0xc8(%rcx), %rdx
imulq %r13, %rdx
addq 0xa8(%rcx), %rdx
movslq %ebp, %rbp
leaq (%rdx,%rbp,4), %rsi
movq (%rcx), %rcx
movq 0x18(%rsp), %rdx
movslq 0x8(%rax,%rdx), %rax
imulq 0x28(%rcx), %rax
addq 0x38(%rcx), %rax
movslq %ebx, %rbx
leaq (%rax,%rbx,4), %rdi
movl %r14d, %edx
movl 0xc(%rsp), %ecx
callq *0x28(%r12)
xorl %ecx, %ecx
movl $0x800, %edi # imm = 0x800
addl %r14d, %ebx
addl %r14d, %ebp
movl 0xc(%r12), %eax
cmpl %eax, %ebp
cmovgel %ecx, %ebp
subl %r14d, %r15d
movl %eax, %r14d
jne 0x56cc51
movq 0x20(%rsp), %rcx
incq %rcx
cmpl %ecx, 0x8(%rsp)
jne 0x56cbe0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x141930
jmp 0x56cd00
movl $0x20, %esi
movq %rax, %rdi
callq 0x137fb0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/corelib/thread/qrunnable.h |
blend_untransformed_rgb565(int, QT_FT_Span_ const*, void*) | static void blend_untransformed_rgb565(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData*>(userData);
QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
if (data->texture.format != QImage::Format_RGB16
|| (mode != QPainter::CompositionMode_SourceOver
&& mode != QPainter::CompositionMode_Source))
{
blend_untransformed_generic(count, spans, userData);
return;
}
const int image_width = data->texture.width;
const int image_height = data->texture.height;
int xoff = -qRound(-data->dx);
int yoff = -qRound(-data->dy);
auto function = [=](int cStart, int cEnd)
{
for (int c = cStart; c < cEnd; ++c) {
if (!spans[c].len)
continue;
const quint8 coverage = (data->texture.const_alpha * spans[c].coverage) >> 8;
if (coverage == 0)
continue;
int x = spans[c].x;
int length = spans[c].len;
int sx = xoff + x;
int sy = yoff + spans[c].y;
if (sy >= 0 && sy < image_height && sx < image_width) {
if (sx < 0) {
x -= sx;
length += sx;
sx = 0;
}
if (sx + length > image_width)
length = image_width - sx;
if (length > 0) {
quint16 *dest = (quint16 *)data->rasterBuffer->scanLine(spans[c].y) + x;
const quint16 *src = (const quint16 *)data->texture.scanLine(sy) + sx;
if (coverage == 255) {
memcpy(dest, src, length * sizeof(quint16));
} else {
const quint8 alpha = (coverage + 1) >> 3;
const quint8 ialpha = 0x20 - alpha;
if (alpha > 0)
blend_sourceOver_rgb16_rgb16(dest, src, length, alpha, ialpha);
}
}
}
}
};
QT_THREAD_PARALLEL_FILLS(function);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movl %edi, %ebx
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
cmpl $0x7, 0xd0(%rdx)
jne 0x56ce2c
movq (%r12), %rax
movl 0xc(%rax), %eax
testl %eax, %eax
je 0x56cd57
cmpl $0x3, %eax
jne 0x56ce2c
movq %rsi, 0x20(%rsp)
movq %r12, 0x28(%rsp)
movupd 0x70(%r12), %xmm0
movapd 0x7a00(%rip), %xmm1 # 0x574770
movapd %xmm0, %xmm2
xorpd %xmm1, %xmm2
andpd %xmm1, %xmm2
orpd 0x79fc(%rip), %xmm2 # 0x574780
subpd %xmm0, %xmm2
cvttpd2dq %xmm2, %xmm0
xorpd %xmm1, %xmm1
psubd %xmm0, %xmm1
movq %xmm1, 0x30(%rsp)
movq 0xb0(%r12), %xmm0
pshufd $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0x38(%rsp)
leal 0x20(%rbx), %eax
leal 0x5f(%rbx), %r13d
testl %eax, %eax
cmovnsl %eax, %r13d
callq 0x138da0
cmpl $0x60, %ebx
jl 0x56cdfb
movq %rax, %r14
testq %rax, %rax
je 0x56cdfb
movq (%r12), %rax
movl 0x10(%rax), %eax
shlq $0x6, %rax
leaq 0x1884b0(%rip), %rcx # 0x6f5290
cmpl $0x3, 0x4(%rcx,%rax)
jl 0x56cdfb
callq 0x141020
movq %r14, %rdi
movq %rax, %rsi
callq 0x13c2a0
testb %al, %al
je 0x56ce58
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x56d1ca
movq %fs:0x28, %rax
cmpq 0x40(%rsp), %rax
jne 0x56cf3e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %fs:0x28, %rax
cmpq 0x40(%rsp), %rax
jne 0x56cf3e
movl %ebx, %edi
movq %r12, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x556b13
sarl $0x6, %r13d
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x13c9f0
cmpl $0x2, %r13d
movl $0x1, %eax
cmovgel %r13d, %eax
negl %eax
movl %eax, 0x4(%rsp)
movq 0x18222e(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
movq %r14, 0x8(%rsp)
movl %ebx, %eax
subl %r15d, %eax
leal (%r12,%r13), %ecx
cltd
idivl %ecx
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %r13, %r14
movq %rax, %r13
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, (%r13)
movl $0x20, %edi
callq 0x1387d0
leaq 0x419(%rip), %rcx # 0x56d2f8
movq %rcx, (%rax)
movl %r15d, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r13)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r14, %r13
movl $0x1, %edx
callq 0x1393d0
addl %ebp, %r15d
decl %r12d
cmpl %r12d, 0x4(%rsp)
jne 0x56cea3
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x143df0
movq %rbx, %rdi
callq 0x13f120
jmp 0x56ce09
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_untransformed_generic_rgb64(int, QT_FT_Span_ const*, void*) | static void blend_untransformed_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, spans, count);
if (!op.func64) {
qCDebug(lcQtGuiDrawHelper, "blend_untransformed_generic_rgb64: unsupported 64-bit blend attempted, falling back to 32-bit");
return blend_untransformed_generic(count, spans, userData);
}
const int image_width = data->texture.width;
const int image_height = data->texture.height;
const int const_alpha = data->texture.const_alpha;
const int xoff = -qRound(-data->dx);
const int yoff = -qRound(-data->dy);
const bool solidSource = op.mode == QPainter::CompositionMode_Source && const_alpha == 256 && op.destFetch64 != destFetchRGB64;
auto function = [=, &op] (int cStart, int cEnd)
{
alignas(16) Q_DECL_UNINITIALIZED QRgba64 buffer[BufferSize];
alignas(16) Q_DECL_UNINITIALIZED QRgba64 src_buffer[BufferSize];
for (int c = cStart; c < cEnd; ++c) {
if (!spans[c].len)
continue;
int x = spans[c].x;
int length = spans[c].len;
int sx = xoff + x;
int sy = yoff + spans[c].y;
const bool fetchDest = !solidSource || spans[c].coverage < 255;
if (sy >= 0 && sy < image_height && sx < image_width) {
if (sx < 0) {
x -= sx;
length += sx;
sx = 0;
}
if (sx + length > image_width)
length = image_width - sx;
if (length > 0) {
const int coverage = (spans[c].coverage * const_alpha) >> 8;
while (length) {
int l = qMin(BufferSize, length);
const QRgba64 *src = op.srcFetch64(src_buffer, &op, data, sy, sx, l);
QRgba64 *dest = fetchDest ? op.destFetch64(buffer, data->rasterBuffer, x, spans[c].y, l) : buffer;
op.func64(dest, src, l, coverage);
if (op.destStore64)
op.destStore64(data->rasterBuffer, x, spans[c].y, dest, l);
x += l;
sx += l;
length -= l;
}
}
}
}
};
QT_THREAD_PARALLEL_FILLS(function);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
leaq 0x61106(%rip), %rsi # 0x5ce8d0
leaq 0x50(%rsp), %r12
movl $0xb0, %edx
movq %r12, %rdi
callq 0x137aa0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x556d77
cmpq $0x0, 0x50(%r12)
je 0x56d8f8
movabsq $-0x5555555555555556, %r13 # imm = 0xAAAAAAAAAAAAAAAA
movl 0xe8(%r15), %eax
movl 0x50(%rsp), %ecx
xorl $0x3, %ecx
movl %eax, %edx
xorl $0x100, %edx # imm = 0x100
orl %ecx, %edx
sete %cl
leaq -0x14e7b(%rip), %rdx # 0x5589a9
cmpq %rdx, 0x80(%rsp)
setne %dl
andb %cl, %dl
movq %r13, 0x38(%rsp)
movq %r12, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movupd 0x70(%r15), %xmm0
movapd 0x6f22(%rip), %xmm1 # 0x574770
movapd %xmm0, %xmm2
xorpd %xmm1, %xmm2
andpd %xmm1, %xmm2
orpd 0x6f1e(%rip), %xmm2 # 0x574780
subpd %xmm0, %xmm2
cvttpd2dq %xmm2, %xmm0
xorpd %xmm1, %xmm1
psubd %xmm0, %xmm1
movq %xmm1, 0x30(%rsp)
movb %dl, 0x38(%rsp)
movq 0xb0(%r15), %xmm0
pshufd $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0x3c(%rsp)
movl %eax, 0x44(%rsp)
movq %r15, 0x48(%rsp)
leal 0x20(%rbp), %eax
leal 0x5f(%rbp), %r14d
testl %eax, %eax
cmovnsl %eax, %r14d
callq 0x138da0
cmpl $0x60, %ebp
jl 0x56d8e8
movq %rax, %rbx
testq %rax, %rax
je 0x56d8e8
movq (%r15), %rax
movl 0x10(%rax), %eax
shlq $0x6, %rax
leaq 0x1879c7(%rip), %rcx # 0x6f5290
cmpl $0x3, 0x4(%rcx,%rax)
jl 0x56d8e8
callq 0x141020
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13c2a0
testb %al, %al
je 0x56d971
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x56df9c
jmp 0x56d948
callq 0x56df86
movb 0x19fe95(%rip), %al # 0x70d798
testb $0x1, %al
je 0x56d93b
movq 0x19fe82(%rip), %rax # 0x70d790
leaq 0x20(%rsp), %rdi
movl $0x2, (%rdi)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x610c8(%rip), %rsi # 0x5ce9fc
xorl %eax, %eax
callq 0x13c920
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x556b13
movq %fs:0x28, %rax
cmpq 0x100(%rsp), %rax
jne 0x56da57
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
sarl $0x6, %r14d
leaq 0x18(%rsp), %rdi
movq %r13, (%rdi)
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x13c9f0
cmpl $0x2, %r14d
movl $0x1, %eax
cmovgel %r14d, %eax
negl %eax
movl %eax, 0x4(%rsp)
movq 0x18171f(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
movq %rbx, 0x8(%rsp)
movl %ebp, %eax
subl %r12d, %eax
leal (%r14,%r15), %ecx
cltd
idivl %ecx
movq %r14, %rbx
movq %rbp, %r14
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r13
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, (%r13)
movl $0x20, %edi
callq 0x1387d0
leaq 0x78f(%rip), %rcx # 0x56e180
movq %rcx, (%rax)
movl %r12d, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r13)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x1393d0
addl %ebp, %r12d
movq %r14, %rbp
movq %rbx, %r14
decl %r15d
cmpl %r15d, 0x4(%rsp)
jne 0x56d9b2
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x143df0
movq %rbx, %rdi
callq 0x13f120
jmp 0x56d948
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_tiled_generic_rgb64(int, QT_FT_Span_ const*, void*) | static void blend_tiled_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, spans, count);
if (!op.func64) {
qCDebug(lcQtGuiDrawHelper, "blend_tiled_generic_rgb64: unsupported 64-bit blend attempted, falling back to 32-bit");
return blend_tiled_generic(count, spans, userData);
}
const int image_width = data->texture.width;
const int image_height = data->texture.height;
int xoff = -qRound(-data->dx) % image_width;
int yoff = -qRound(-data->dy) % image_height;
if (xoff < 0)
xoff += image_width;
if (yoff < 0)
yoff += image_height;
bool isBpp32 = qPixelLayouts[data->rasterBuffer->format].bpp == QPixelLayout::BPP32;
bool isBpp64 = qPixelLayouts[data->rasterBuffer->format].bpp == QPixelLayout::BPP64;
if (op.destFetch64 == destFetch64Undefined && image_width <= BufferSize && (isBpp32 || isBpp64)) {
alignas(16) Q_DECL_UNINITIALIZED QRgba64 src_buffer[BufferSize];
// If destination isn't blended into the result, we can do the tiling directly on destination pixels.
while (count--) {
int x = spans->x;
int y = spans->y;
int length = spans->len;
int sx = (xoff + spans->x) % image_width;
int sy = (spans->y + yoff) % image_height;
if (sx < 0)
sx += image_width;
if (sy < 0)
sy += image_height;
int sl = qMin(image_width, length);
if (sx > 0 && sl > 0) {
int l = qMin(image_width - sx, sl);
const QRgba64 *src = op.srcFetch64(src_buffer, &op, data, sy, sx, l);
op.destStore64(data->rasterBuffer, x, y, src, l);
x += l;
sx += l;
sl -= l;
if (sx >= image_width)
sx = 0;
}
if (sl > 0) {
Q_ASSERT(sx == 0);
const QRgba64 *src = op.srcFetch64(src_buffer, &op, data, sy, sx, sl);
op.destStore64(data->rasterBuffer, x, y, src, sl);
x += sl;
sx += sl;
sl -= sl;
if (sx >= image_width)
sx = 0;
}
if (isBpp32) {
uint *dest = reinterpret_cast<uint *>(data->rasterBuffer->scanLine(y)) + x - image_width;
for (int i = image_width; i < length; ++i)
dest[i] = dest[i - image_width];
} else {
quint64 *dest = reinterpret_cast<quint64 *>(data->rasterBuffer->scanLine(y)) + x - image_width;
for (int i = image_width; i < length; ++i)
dest[i] = dest[i - image_width];
}
++spans;
}
return;
}
auto function = [=, &op](int cStart, int cEnd)
{
alignas(16) Q_DECL_UNINITIALIZED QRgba64 buffer[BufferSize];
alignas(16) Q_DECL_UNINITIALIZED QRgba64 src_buffer[BufferSize];
for (int c = cStart; c < cEnd; ++c) {
int x = spans[c].x;
int length = spans[c].len;
int sx = (xoff + spans[c].x) % image_width;
int sy = (spans[c].y + yoff) % image_height;
if (sx < 0)
sx += image_width;
if (sy < 0)
sy += image_height;
const int coverage = (spans[c].coverage * data->texture.const_alpha) >> 8;
while (length) {
int l = qMin(image_width - sx, length);
if (BufferSize < l)
l = BufferSize;
const QRgba64 *src = op.srcFetch64(src_buffer, &op, data, sy, sx, l);
QRgba64 *dest = op.destFetch64(buffer, data->rasterBuffer, x, spans[c].y, l);
op.func64(dest, src, l, coverage);
if (op.destStore64)
op.destStore64(data->rasterBuffer, x, spans[c].y, dest, l);
x += l;
sx += l;
length -= l;
if (sx >= image_width)
sx = 0;
}
}
};
QT_THREAD_PARALLEL_FILLS(function);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4128, %rsp # imm = 0x4128
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
movq %fs:0x28, %rax
movq %rax, 0x4120(%rsp)
leaq 0x60e3f(%rip), %rsi # 0x5ce8d0
leaq 0x70(%rsp), %r12
movl $0xb0, %edx
movq %r12, %rdi
callq 0x137aa0
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, (%rsp)
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x556d77
cmpq $0x0, 0x50(%r12)
je 0x56dd76
movslq 0xb0(%r14), %rsi
movl 0xb4(%r14), %edi
movsd 0x70(%r14), %xmm0
movapd 0x6c91(%rip), %xmm1 # 0x574770
movapd %xmm0, %xmm2
xorpd %xmm1, %xmm2
andpd %xmm1, %xmm2
movapd 0x6c8d(%rip), %xmm3 # 0x574780
orpd %xmm3, %xmm2
subsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
cltd
idivl %esi
movl %edx, %ecx
movsd 0x78(%r14), %xmm0
movapd %xmm0, %xmm2
xorpd %xmm1, %xmm2
andpd %xmm1, %xmm2
orpd %xmm3, %xmm2
subsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
cltd
idivl %edi
xorl %eax, %eax
testl %ecx, %ecx
movl $0x0, %r8d
cmovgl %esi, %r8d
subl %ecx, %r8d
movq %r8, 0x48(%rsp)
testl %edx, %edx
movl %edi, 0x14(%rsp)
cmovgl %edi, %eax
subl %edx, %eax
movq %rax, 0x50(%rsp)
leaq 0x18773e(%rip), %rbx # 0x6f5290
cmpq $0x800, %rsi # imm = 0x800
movq %r14, 0x18(%rsp)
jg 0x56ddcf
leaq -0x151aa(%rip), %rax # 0x5589c1
cmpq %rax, 0xa0(%rsp)
jne 0x56ddcf
movq (%r14), %rax
movl 0x10(%rax), %eax
shlq $0x6, %rax
movl 0x4(%rbx,%rax), %eax
movl %eax, 0x2c(%rsp)
andl $-0x2, %eax
cmpl $0x6, %eax
jne 0x56ddcf
testl %ebp, %ebp
je 0x56de75
movq %rsi, %rax
negq %rax
movq %rax, 0x30(%rsp)
leaq (,%rsi,8), %rdx
negq %rdx
movq %rsi, %rdi
shlq $0x2, %rdi
negq %rdi
movq %rsi, 0x58(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq (%rsp), %rax
movl (%rax), %r8d
movslq 0x8(%rax), %rdi
movslq 0x4(%rax), %r12
movq 0x48(%rsp), %rax
addl %r8d, %eax
cltd
idivl %esi
movl %edx, %ecx
movq 0x50(%rsp), %rax
movq %rdi, 0x8(%rsp)
addl %edi, %eax
cltd
movl 0x14(%rsp), %edi
idivl %edi
movl %ecx, %r14d
sarl $0x1f, %r14d
andl %esi, %r14d
movl %edx, %ebx
sarl $0x1f, %ebx
andl %edi, %ebx
addl %edx, %ebx
cmpl %r12d, %esi
movl %r12d, %r13d
cmovll %esi, %r13d
addl %ecx, %r14d
jle 0x56dc9e
testl %r13d, %r13d
jle 0x56dc9e
movq %rbp, 0x20(%rsp)
movl %esi, %r15d
subl %r14d, %r15d
cmpl %r13d, %r15d
cmovgel %r13d, %r15d
leaq 0x120(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq 0x18(%rsp), %rbp
movq %rbp, %rdx
movl %ebx, %ecx
movq %r8, 0x60(%rsp)
movl %r14d, %r8d
movl %r15d, %r9d
callq *0xb0(%rsp)
movq (%rbp), %rdi
movq 0x60(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
movl %r15d, %r8d
callq *0xa8(%rsp)
movq 0x60(%rsp), %r8
movq 0x58(%rsp), %rsi
addl %r15d, %r8d
addl %r15d, %r14d
subl %r15d, %r13d
movq 0x20(%rsp), %rbp
cmpl %esi, %r14d
movl $0x0, %eax
cmovgel %eax, %r14d
testl %r13d, %r13d
jle 0x56dcfc
leaq 0x120(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl %ebx, %ecx
movq %r8, %r15
movl %r14d, %r8d
movq %rdx, %rbx
movl %r13d, %r9d
callq *0xb0(%rsp)
movq (%rbx), %rdi
movl %r15d, %esi
movq 0x8(%rsp), %r14
movl %r14d, %edx
movq %rax, %rcx
movl %r13d, %r8d
callq *0xa8(%rsp)
movq %r15, %r8
movq 0x58(%rsp), %rsi
addl %r13d, %r8d
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rdi
jmp 0x56dd10
movq 0x18(%rsp), %rbx
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %r14
movq (%rbx), %rax
imulq 0x28(%rax), %r14
addq 0x38(%rax), %r14
movslq %r8d, %rax
cmpl $0x6, 0x2c(%rsp)
jne 0x56dd44
cmpl %r12d, %esi
jge 0x56dd62
leaq (%r14,%rax,4), %rax
addq 0x30(%rsp), %r12
movl (%rax,%rdi), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
decq %r12
jne 0x56dd34
jmp 0x56dd62
cmpl %r12d, %esi
jge 0x56dd62
leaq (%r14,%rax,8), %rax
addq 0x30(%rsp), %r12
movq (%rax,%rdx), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
decq %r12
jne 0x56dd52
decl %ebp
addq $0x10, (%rsp)
testl %ebp, %ebp
jne 0x56dbce
jmp 0x56de75
callq 0x56df86
movb 0x19fa17(%rip), %al # 0x70d798
testb $0x1, %al
je 0x56ddbc
movq 0x19fa04(%rip), %rax # 0x70d790
leaq 0x120(%rsp), %rdi
movl $0x2, (%rdi)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x60cb7(%rip), %rsi # 0x5cea6c
xorl %eax, %eax
callq 0x13c920
movl %ebp, %edi
movq (%rsp), %rsi
movq %r14, %rdx
callq 0x56c73c
jmp 0x56de75
movq %r12, 0x120(%rsp)
movq (%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x48(%rsp), %rax
movl %eax, 0x130(%rsp)
movl %esi, 0x134(%rsp)
movq 0x50(%rsp), %rax
movl %eax, 0x138(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x13c(%rsp)
movq %r14, 0x140(%rsp)
leal 0x20(%rbp), %eax
movq %rbp, %r15
addl $0x5f, %ebp
testl %eax, %eax
cmovnsl %eax, %ebp
callq 0x138da0
movq %r15, %r14
cmpl $0x60, %r15d
jl 0x56de63
movq %rax, %r12
testq %rax, %rax
je 0x56de63
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shlq $0x6, %rax
cmpl $0x3, 0x4(%rbx,%rax)
jl 0x56de63
callq 0x141020
movq %r12, %rdi
movq %rax, %rsi
callq 0x13c2a0
testb %al, %al
je 0x56de9e
leaq 0x120(%rsp), %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x56e1c4
movq %fs:0x28, %rax
cmpq 0x4120(%rsp), %rax
jne 0x56df81
addq $0x4128, %rsp # imm = 0x4128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
sarl $0x6, %ebp
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x68(%rsp), %rdi
movq %rax, (%rdi)
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x13c9f0
cmpl $0x2, %ebp
movl $0x1, %eax
cmovgel %ebp, %eax
negl %eax
movl %eax, 0x8(%rsp)
movq 0x1811eb(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, (%rsp)
xorl %ebx, %ebx
movq %r14, 0x20(%rsp)
movq %r12, %r15
movq 0x20(%rsp), %rax
subl %ebx, %eax
leal (%rbp,%r13), %ecx
cltd
idivl %ecx
movq %rbp, %r12
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r14
movb $0x1, 0x8(%rax)
movq (%rsp), %rax
movq %rax, (%r14)
movl $0x20, %edi
callq 0x1387d0
leaq 0x436(%rip), %rcx # 0x56e35a
movq %rcx, (%rax)
movl %ebx, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x120(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x68(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r14)
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x1393d0
addl %ebp, %ebx
movq %r12, %rbp
decl %r13d
cmpl %r13d, 0x8(%rsp)
jne 0x56dee7
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x143df0
movq %rbx, %rdi
callq 0x13f120
jmp 0x56de75
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_tiled_generic_fp(int, QT_FT_Span_ const*, void*) | static void blend_tiled_generic_fp(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, spans, count);
if (!op.funcFP) {
qCDebug(lcQtGuiDrawHelper, "blend_tiled_generic_fp: unsupported 4xFP blend attempted, falling back to 32-bit");
return blend_tiled_generic(count, spans, userData);
}
const int image_width = data->texture.width;
const int image_height = data->texture.height;
int xoff = -qRound(-data->dx) % image_width;
int yoff = -qRound(-data->dy) % image_height;
if (xoff < 0)
xoff += image_width;
if (yoff < 0)
yoff += image_height;
// Consider tiling optimizing like the other versions.
auto function = [=, &op](int cStart, int cEnd)
{
alignas(16) Q_DECL_UNINITIALIZED QRgbaFloat32 buffer[BufferSize];
alignas(16) Q_DECL_UNINITIALIZED QRgbaFloat32 src_buffer[BufferSize];
for (int c = cStart; c < cEnd; ++c) {
int x = spans[c].x;
int length = spans[c].len;
int sx = (xoff + spans[c].x) % image_width;
int sy = (spans[c].y + yoff) % image_height;
if (sx < 0)
sx += image_width;
if (sy < 0)
sy += image_height;
const int coverage = (spans[c].coverage * data->texture.const_alpha) >> 8;
while (length) {
int l = qMin(image_width - sx, length);
if (BufferSize < l)
l = BufferSize;
const QRgbaFloat32 *src = op.srcFetchFP(src_buffer, &op, data, sy, sx, l);
QRgbaFloat32 *dest = op.destFetchFP(buffer, data->rasterBuffer, x, spans[c].y, l);
op.funcFP(dest, src, l, coverage);
if (op.destStoreFP)
op.destStoreFP(data->rasterBuffer, x, spans[c].y, dest, l);
x += l;
sx += l;
length -= l;
if (sx >= image_width)
sx = 0;
}
}
};
QT_THREAD_PARALLEL_FILLS(function);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r13d
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
leaq 0x60231(%rip), %rsi # 0x5ce8d0
leaq 0x50(%rsp), %r12
movl $0xb0, %edx
movq %r12, %rdi
callq 0x137aa0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %r13d, %ecx
callq 0x556d77
cmpq $0x0, 0x78(%r12)
je 0x56e7cb
movl 0xb0(%r14), %r8d
movl 0xb4(%r14), %edi
movsd 0x70(%r14), %xmm0
movsd 0x78(%r14), %xmm1
movapd 0x6080(%rip), %xmm2 # 0x574770
movapd %xmm0, %xmm3
xorpd %xmm2, %xmm3
andpd %xmm2, %xmm3
movapd 0x607c(%rip), %xmm4 # 0x574780
orpd %xmm4, %xmm3
subsd %xmm0, %xmm3
cvttsd2si %xmm3, %eax
cltd
movapd %xmm1, %xmm0
xorpd %xmm2, %xmm0
andpd %xmm2, %xmm0
orpd %xmm4, %xmm0
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
idivl %r8d
movl %edx, %esi
movl %ecx, %eax
cltd
idivl %edi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %r8d, %ecx
subl %esi, %ecx
testl %edx, %edx
cmovgl %edi, %eax
subl %edx, %eax
movq %r12, 0x28(%rsp)
movq %r15, 0x30(%rsp)
movl %ecx, 0x38(%rsp)
movl %r8d, 0x3c(%rsp)
movl %eax, 0x40(%rsp)
movl %edi, 0x44(%rsp)
movq %r14, 0x48(%rsp)
leal 0x20(%r13), %eax
leal 0x5f(%r13), %r12d
testl %eax, %eax
cmovnsl %eax, %r12d
callq 0x138da0
cmpl $0x60, %r13d
jl 0x56e7ba
movq %rax, %rbx
testq %rax, %rax
je 0x56e7ba
movq (%r14), %rax
movl 0x10(%rax), %eax
shlq $0x6, %rax
leaq 0x186af5(%rip), %rcx # 0x6f5290
cmpl $0x3, 0x4(%rcx,%rax)
jl 0x56e7ba
callq 0x141020
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13c2a0
testb %al, %al
je 0x56e845
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x56eb6a
jmp 0x56e81c
callq 0x56df86
movb 0x19efc2(%rip), %al # 0x70d798
testb $0x1, %al
je 0x56e80e
movq 0x19efaf(%rip), %rax # 0x70d790
leaq 0x28(%rsp), %rdi
movl $0x2, (%rdi)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x6031b(%rip), %rsi # 0x5ceb22
xorl %eax, %eax
callq 0x13c920
movl %r13d, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x56c73c
movq %fs:0x28, %rax
cmpq 0x100(%rsp), %rax
jne 0x56e936
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
sarl $0x6, %r12d
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x13c9f0
cmpl $0x2, %r12d
movl $0x1, %eax
cmovgel %r12d, %eax
negl %eax
movl %eax, 0xc(%rsp)
movq 0x180841(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
movq %rbx, 0x10(%rsp)
movl %r13d, %eax
subl %r15d, %eax
leal (%r12,%r14), %ecx
cltd
idivl %ecx
movl %eax, %ebp
movl $0x18, %edi
callq 0x1387d0
movq %r12, %rbx
movq %r13, %r12
movq %rax, %r13
movb $0x1, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%r13)
movl $0x20, %edi
callq 0x1387d0
leaq 0x430(%rip), %rcx # 0x56ed00
movq %rcx, (%rax)
movl %r15d, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r12, %r13
movq %rbx, %r12
movl $0x1, %edx
callq 0x1393d0
addl %ebp, %r15d
decl %r14d
cmpl %r14d, 0xc(%rsp)
jne 0x56e890
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x143df0
movq %rbx, %rdi
callq 0x13f120
jmp 0x56e81c
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
QRunnable::QGenericRunnable::Helper<blend_color_argb(int, QT_FT_Span_ const*, void*)::$_0>::impl(QRunnable::QGenericRunnable::HelperBase::Op, QRunnable::QGenericRunnable::HelperBase*, void*) | static void *impl(Op op, HelperBase *that, [[maybe_unused]] void *arg)
{
const auto _this = static_cast<Helper*>(that);
switch (op) {
case Op::Run: _this->object()(); break;
case Op::Destroy: delete _this; break;
}
return nullptr;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x1, %edi
je 0x56f993
testl %edi, %edi
jne 0x56f9a0
movl 0xc(%rbx), %ebp
testl %ebp, %ebp
jle 0x56f983
movq 0x10(%rbx), %r14
movslq 0x8(%rbx), %r15
shlq $0x4, %r15
orq $0xc, %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rax), %rax
movslq -0x4(%rcx,%r15), %rdx
imulq 0x28(%rax), %rdx
addq 0x38(%rax), %rdx
movslq -0xc(%rcx,%r15), %rax
leaq (%rdx,%rax,4), %rdi
movl -0x8(%rcx,%r15), %esi
movl 0x18(%r14), %edx
movzbl (%rcx,%r15), %ecx
callq *0x10(%r14)
addq $0x10, %r15
decl %ebp
jne 0x56f948
movq 0x18(%rbx), %rdi
movl $0x1, %esi
callq 0x141930
jmp 0x56f9a0
movl $0x20, %esi
movq %rbx, %rdi
callq 0x137fb0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/corelib/thread/qrunnable.h |
void qt_bitmapblit_template<unsigned int>(QRasterBuffer*, int, int, unsigned int, unsigned char const*, int, int, int) | static
inline void qt_bitmapblit_template(QRasterBuffer *rasterBuffer,
int x, int y, DST color,
const uchar *map,
int mapWidth, int mapHeight, int mapStride)
{
DST *dest = reinterpret_cast<DST *>(rasterBuffer->scanLine(y)) + x;
const int destStride = rasterBuffer->stride<DST>();
if (mapWidth > 8) {
while (--mapHeight >= 0) {
int x0 = 0;
int n = 0;
for (int x = 0; x < mapWidth; x += 8) {
uchar s = map[x >> 3];
for (int i = 0; i < 8; ++i) {
if (s & 0x80) {
++n;
} else {
if (n) {
qt_memfill(dest + x0, color, n);
x0 += n + 1;
n = 0;
} else {
++x0;
}
if (!s) {
x0 += 8 - 1 - i;
break;
}
}
s <<= 1;
}
}
if (n)
qt_memfill(dest + x0, color, n);
dest += destStride;
map += mapStride;
}
} else {
while (--mapHeight >= 0) {
int x0 = 0;
int n = 0;
for (uchar s = *map; s; s <<= 1) {
if (s & 0x80) {
++n;
} else if (n) {
qt_memfill(dest + x0, color, n);
x0 += n + 1;
n = 0;
} else {
++x0;
}
}
if (n)
qt_memfill(dest + x0, color, n);
dest += destStride;
map += mapStride;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movl %r8d, 0xc(%rsp)
movl 0x80(%rsp), %eax
movl 0x78(%rsp), %r12d
movslq %ecx, %rcx
imulq %rdi, %rcx
addq %rsi, %rcx
movslq %edx, %rdx
leaq (%rcx,%rdx,4), %r15
shrq $0x2, %rdi
cmpl $0x8, 0x70(%rsp)
jle 0x56fae1
testl %r12d, %r12d
jle 0x56fb70
movslq %edi, %rcx
movq %rcx, 0x28(%rsp)
cltq
movq %rax, 0x20(%rsp)
movq %r12, 0x30(%rsp)
leal -0x1(%r12), %eax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %rbx, 0x10(%rsp)
movq %r14, %rax
shrq $0x3, %rax
movb (%rbx,%rax), %bpl
movl $0xfffffff8, %ebx # imm = 0xFFFFFFF8
testb %bpl, %bpl
js 0x56fa59
testl %r12d, %r12d
je 0x56fa5e
movslq %r13d, %rax
leaq (%r15,%rax,4), %rdi
movslq %r12d, %rdx
movl 0xc(%rsp), %esi
callq *0x19dd1e(%rip) # 0x70d770
leal 0x1(%r12), %eax
jmp 0x56fa63
incl %r12d
jmp 0x56fa6e
movl $0x1, %eax
testb %bpl, %bpl
je 0x56fa87
addl %eax, %r13d
xorl %r12d, %r12d
addb %bpl, %bpl
incl %ebx
jne 0x56fa34
addq $0x8, %r14
cmpl 0x70(%rsp), %r14d
movq 0x10(%rsp), %rbx
jl 0x56fa24
jmp 0x56faa5
addl %r13d, %r12d
movl %r12d, %r13d
subl %ebx, %r13d
addq $0x8, %r14
xorl %r12d, %r12d
cmpl 0x70(%rsp), %r14d
movq 0x10(%rsp), %rbx
jl 0x56fa24
jmp 0x56fabe
testl %r12d, %r12d
je 0x56fabe
movslq %r13d, %rax
leaq (%r15,%rax,4), %rdi
movslq %r12d, %rdx
movl 0xc(%rsp), %esi
callq *0x19dcb2(%rip) # 0x70d770
movq 0x28(%rsp), %rax
leaq (%r15,%rax,4), %r15
addq 0x20(%rsp), %rbx
cmpl $0x1, 0x30(%rsp)
movq 0x18(%rsp), %r12
jg 0x56fa07
jmp 0x56fb70
testl %r12d, %r12d
jle 0x56fb70
movslq %edi, %rcx
movq %rcx, 0x10(%rsp)
cltq
movq %rax, 0x18(%rsp)
movq %rbx, %r14
movb (%rbx), %bl
testb %bl, %bl
je 0x56fb51
xorl %r13d, %r13d
xorl %eax, %eax
testb %bl, %bl
js 0x56fb14
testl %r13d, %r13d
jne 0x56fb19
incl %eax
jmp 0x56fb32
incl %r13d
jmp 0x56fb35
movslq %eax, %rbp
leaq (%r15,%rbp,4), %rdi
movslq %r13d, %rdx
movl 0xc(%rsp), %esi
callq *0x19dc43(%rip) # 0x70d770
leal 0x1(%rbp,%r13), %eax
xorl %r13d, %r13d
addb %bl, %bl
jne 0x56fb07
testl %r13d, %r13d
je 0x56fb51
cltq
leaq (%r15,%rax,4), %rdi
movslq %r13d, %rdx
movl 0xc(%rsp), %esi
callq *0x19dc1f(%rip) # 0x70d770
leal -0x1(%r12), %eax
movq 0x10(%rsp), %rcx
leaq (%r15,%rcx,4), %r15
movq %r14, %rbx
addq 0x18(%rsp), %rbx
cmpl $0x1, %r12d
movl %eax, %r12d
jg 0x56faf9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
qt_alphamapblit_argb32_oneline(unsigned char const*, int, QRgba64 const&, unsigned int*, unsigned int, QColorTrcLut const*) | static void qt_alphamapblit_argb32_oneline(const uchar *map,
int mapWidth, const QRgba64 &srcColor,
quint32 *dest, const quint32 c,
const QColorTrcLut *colorProfile)
{
for (int i = 0; i < mapWidth; ++i)
alphamapblend_argb32(dest + i, map[i], srcColor, c, colorProfile);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
testl %esi, %esi
jle 0x56ffca
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdi, %r12
movabsq $0xff00ff00ff00ff, %rdi # imm = 0xFF00FF00FF00FF
movabsq $0x80008000800080, %r8 # imm = 0x80008000800080
movl %ebp, %eax
movq %rax, %rcx
shlq $0x18, %rcx
orq %rax, %rcx
andq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movl %ebp, %eax
notl %eax
shrl $0x18, %eax
movq %rax, (%rsp)
movl %esi, %r15d
xorl %r13d, %r13d
movzbl (%r12,%r13), %eax
testl %eax, %eax
je 0x56ffbe
testq %rbx, %rbx
je 0x56fc84
cmpb $-0x1, %al
je 0x56fc84
movl (%r14,%r13,4), %ecx
movl %ecx, %edx
shrl $0x18, %edx
cmpl $0xfe, %edx
ja 0x56fd06
testl %ebp, %ebp
je 0x56ffbe
movl %eax, %eax
imulq 0x8(%rsp), %rax
movq %rax, %rdx
shrq $0x8, %rdx
andq %rdi, %rdx
addq %r8, %rax
addq %rdx, %rax
movq %rax, %rsi
shrq $0x8, %rsi
andq %rdi, %rsi
movq %rsi, %rdx
shrq $0x18, %rdx
orl %esi, %edx
notq %rax
shrq $0x38, %rax
movq %rcx, %rsi
shlq $0x18, %rsi
orq %rcx, %rsi
andq %rdi, %rsi
imulq %rax, %rsi
movq %rsi, %rax
shrq $0x8, %rax
andq %rdi, %rax
addq %r8, %rsi
addq %rax, %rsi
shrq $0x8, %rsi
andq %rdi, %rsi
movq %rsi, %rax
shrq $0x18, %rax
orl %esi, %eax
addl %edx, %eax
jmp 0x56ffba
cmpl $0xff, %eax
je 0x56fdf6
testl %ebp, %ebp
je 0x56ffbe
movq 0x8(%rsp), %rdx
imulq %rax, %rdx
movq %rdx, %rax
shrq $0x8, %rax
andq %rdi, %rax
addq %r8, %rdx
addq %rax, %rdx
movq %rdx, %rax
shrq $0x8, %rax
andq %rdi, %rax
movq %rax, %rcx
shrq $0x18, %rcx
orl %eax, %ecx
movl (%r14,%r13,4), %eax
notq %rdx
shrq $0x38, %rdx
movq %rax, %rsi
shlq $0x18, %rsi
orq %rax, %rsi
andq %rdi, %rsi
imulq %rdx, %rsi
movq %rsi, %rax
shrq $0x8, %rax
andq %rdi, %rax
addq %r8, %rsi
addq %rax, %rsi
shrq $0x8, %rsi
andq %rdi, %rsi
movq %rsi, %rax
shrq $0x18, %rax
orl %esi, %eax
addl %ecx, %eax
jmp 0x56ffba
cmpl $0xff000000, %ebp # imm = 0xFF000000
jb 0x56fe49
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x56ffde
movd %ecx, %xmm0
pxor %xmm1, %xmm1
punpcklbw %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
pxor %xmm5, %xmm5
punpcklbw %xmm5, %xmm0 # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1],xmm0[2],xmm5[2],xmm0[3],xmm5[3],xmm0[4],xmm5[4],xmm0[5],xmm5[5],xmm0[6],xmm5[6],xmm0[7],xmm5[7]
psllw $0x4, %xmm0
pextrw $0x2, %xmm0, %ecx
pextrw $0x0, %xmm0, %esi
pextrw $0x1, %xmm0, %edi
pinsrw $0x0, (%rdx,%rcx,2), %xmm1
pinsrw $0x1, (%rdx,%rdi,2), %xmm1
pinsrw $0x2, (%rdx,%rsi,2), %xmm1
movdqa %xmm1, %xmm2
psrlw $0x8, %xmm2
paddw %xmm1, %xmm2
movl %eax, %ecx
xorl $0xff, %ecx
movq 0x10(%rsp), %rdx
movq (%rdx), %xmm0
movq %xmm2, %xmm1 # xmm1 = xmm2[0],zero
movl %eax, %edx
shll $0x8, %edx
orl %eax, %edx
movd %edx, %xmm3
pshuflw $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0,4,5,6,7]
movdqa %xmm3, %xmm4
pmullw %xmm0, %xmm4
pmulhuw %xmm3, %xmm0
punpcklwd %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1],xmm4[2],xmm0[2],xmm4[3],xmm0[3]
punpcklwd %xmm5, %xmm0 # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1],xmm0[2],xmm5[2],xmm0[3],xmm5[3]
paddd %xmm4, %xmm0
movdqa 0x29d06(%rip), %xmm4 # 0x599ab0
paddd %xmm4, %xmm0
psrad $0x10, %xmm0
packssdw %xmm0, %xmm0
movl %ecx, %eax
shll $0x8, %eax
orl %ecx, %eax
movd %eax, %xmm3
pshuflw $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0,4,5,6,7]
pmullw %xmm3, %xmm2
pmulhuw %xmm3, %xmm1
punpcklwd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
punpcklwd %xmm5, %xmm1 # xmm1 = xmm1[0],xmm5[0],xmm1[1],xmm5[1],xmm1[2],xmm5[2],xmm1[3],xmm5[3]
paddd %xmm2, %xmm1
paddd %xmm4, %xmm1
psrad $0x10, %xmm1
packssdw %xmm1, %xmm1
paddw %xmm0, %xmm1
movq %xmm1, %rsi
jmp 0x56ff9e
movl %ebp, %eax
cmpl $0xfeffffff, %ebp # imm = 0xFEFFFFFF
ja 0x56ffba
testl %ebp, %ebp
je 0x56ffbe
movl (%r14,%r13,4), %eax
movq %rax, %rcx
shlq $0x18, %rcx
orq %rax, %rcx
andq %rdi, %rcx
imulq (%rsp), %rcx
movq %rcx, %rax
shrq $0x8, %rax
andq %rdi, %rax
addq %r8, %rcx
addq %rax, %rcx
shrq $0x8, %rcx
andq %rdi, %rcx
movq %rcx, %rax
shrq $0x18, %rax
orl %ecx, %eax
addl %ebp, %eax
jmp 0x56ffba
movl %ecx, %esi
testl %ebp, %ebp
je 0x56fe83
movq %rcx, %rdx
shlq $0x18, %rdx
orq %rcx, %rdx
andq %rdi, %rdx
imulq (%rsp), %rdx
movq %rdx, %rsi
shrq $0x8, %rsi
andq %rdi, %rsi
addq %r8, %rdx
addq %rsi, %rdx
shrq $0x8, %rdx
andq %rdi, %rdx
movq %rdx, %rsi
shrq $0x18, %rsi
orl %edx, %esi
addl %ebp, %esi
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x56ffd9
movd %esi, %xmm0
pxor %xmm1, %xmm1
punpcklbw %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
pxor %xmm5, %xmm5
punpcklbw %xmm5, %xmm0 # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1],xmm0[2],xmm5[2],xmm0[3],xmm5[3],xmm0[4],xmm5[4],xmm0[5],xmm5[5],xmm0[6],xmm5[6],xmm0[7],xmm5[7]
psllw $0x4, %xmm0
pextrw $0x2, %xmm0, %esi
pextrw $0x0, %xmm0, %edi
pextrw $0x1, %xmm0, %r8d
pinsrw $0x0, (%rdx,%rsi,2), %xmm1
pinsrw $0x1, (%rdx,%r8,2), %xmm1
pinsrw $0x2, (%rdx,%rdi,2), %xmm1
movdqa %xmm1, %xmm0
psrlw $0x8, %xmm0
movd %ecx, %xmm2
pxor %xmm4, %xmm4
punpcklbw %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1],xmm4[2],xmm2[2],xmm4[3],xmm2[3],xmm4[4],xmm2[4],xmm4[5],xmm2[5],xmm4[6],xmm2[6],xmm4[7],xmm2[7]
punpcklbw %xmm5, %xmm2 # xmm2 = xmm2[0],xmm5[0],xmm2[1],xmm5[1],xmm2[2],xmm5[2],xmm2[3],xmm5[3],xmm2[4],xmm5[4],xmm2[5],xmm5[5],xmm2[6],xmm5[6],xmm2[7],xmm5[7]
psllw $0x4, %xmm2
pextrw $0x2, %xmm2, %ecx
pextrw $0x0, %xmm2, %esi
pextrw $0x1, %xmm2, %edi
pinsrw $0x0, (%rdx,%rcx,2), %xmm4
pinsrw $0x1, (%rdx,%rdi,2), %xmm4
pinsrw $0x2, (%rdx,%rsi,2), %xmm4
paddw %xmm1, %xmm0
movdqa %xmm4, %xmm3
psrlw $0x8, %xmm3
paddw %xmm4, %xmm3
movl %eax, %ecx
xorl $0xff, %ecx
movq %xmm0, %xmm1 # xmm1 = xmm0[0],zero
movq %xmm3, %xmm2 # xmm2 = xmm3[0],zero
movl %eax, %edx
shll $0x8, %edx
orl %eax, %edx
movd %edx, %xmm4
pshuflw $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0,4,5,6,7]
pmullw %xmm4, %xmm0
pmulhuw %xmm4, %xmm1
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
punpcklwd %xmm5, %xmm1 # xmm1 = xmm1[0],xmm5[0],xmm1[1],xmm5[1],xmm1[2],xmm5[2],xmm1[3],xmm5[3]
paddd %xmm0, %xmm1
movdqa 0x29b59(%rip), %xmm4 # 0x599ab0
paddd %xmm4, %xmm1
psrad $0x10, %xmm1
packssdw %xmm1, %xmm1
movl %ecx, %eax
shll $0x8, %eax
orl %ecx, %eax
movd %eax, %xmm0
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pmullw %xmm0, %xmm3
pmulhuw %xmm0, %xmm2
punpcklwd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1],xmm3[2],xmm2[2],xmm3[3],xmm2[3]
punpcklwd %xmm5, %xmm2 # xmm2 = xmm2[0],xmm5[0],xmm2[1],xmm5[1],xmm2[2],xmm5[2],xmm2[3],xmm5[3]
paddd %xmm3, %xmm2
paddd %xmm4, %xmm2
psrad $0x10, %xmm2
packssdw %xmm2, %xmm2
paddw %xmm1, %xmm2
movq %xmm2, %rsi
movq %rbx, %rdi
callq 0x5720be
movabsq $0x80008000800080, %r8 # imm = 0x80008000800080
movabsq $0xff00ff00ff00ff, %rdi # imm = 0xFF00FF00FF00FF
movl %eax, (%r14,%r13,4)
incq %r13
cmpq %r13, %r15
jne 0x56fbdf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x16431a
callq 0x16433a
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
alphargbblend_argb32(unsigned int*, unsigned int, QRgba64 const&, unsigned int, QColorTrcLut const*) | static inline void alphargbblend_argb32(quint32 *dst, uint coverage, const QRgba64 &srcLinear, quint32 src, const QColorTrcLut *colorProfile)
{
if (coverage == 0xff000000) {
// nothing
} else if (coverage == 0xffffffff && qAlpha(src) == 255) {
blend_pixel(*dst, src);
} else if (*dst < 0xff000000) {
// Give up and do a naive gray alphablend. Needed to deal with ARGB32 and invalid ARGB32_premultiplied, see QTBUG-60571
blend_pixel(*dst, src, qRgbAvg(coverage));
} else if (!colorProfile) {
// First do naive blend with text-color
QRgb s = *dst;
blend_pixel(s, src);
// Then a naive blend with glyph shape
*dst = rgbBlend(*dst, s, coverage);
} else if (srcLinear.isOpaque()) {
rgbBlendPixel(dst, coverage, srcLinear, colorProfile);
} else {
// First do naive blend with text-color
QRgb s = *dst;
blend_pixel(s, src);
// Then gamma-corrected blend with glyph shape
QRgba64 s64 = colorProfile ? colorProfile->toLinear64(s) : QRgba64::fromArgb32(s);
rgbBlendPixel(dst, coverage, s64, colorProfile);
}
} | pushq %rbx
cmpl $0xff000000, %esi # imm = 0xFF000000
je 0x570431
movq %rdi, %rbx
cmpl $-0x1, %esi
jne 0x570004
cmpl $0xfeffffff, %ecx # imm = 0xFEFFFFFF
ja 0x57042f
movl (%rbx), %eax
movl %eax, %edi
shrl $0x18, %edi
cmpl $0xfe, %edi
ja 0x5700ad
movl %esi, %edx
shrl $0x10, %edx
movl $0xff, %edi
andl %edi, %edx
movl %esi, %r8d
shrl $0x8, %r8d
andl %edi, %r8d
leal (%r8,%r8,2), %r8d
andl %edi, %esi
addl %edx, %esi
leal (%rsi,%rsi,4), %edx
leal (%rdx,%r8,2), %edx
shrl $0x4, %edx
cmpl %edi, %edx
jne 0x570184
cmpl $0xfeffffff, %ecx # imm = 0xFEFFFFFF
ja 0x57042f
testl %ecx, %ecx
je 0x570431
movl %ecx, %edx
notl %edx
shrl $0x18, %edx
movq %rax, %rsi
shlq $0x18, %rsi
orq %rax, %rsi
movabsq $0xff00ff00ff00ff, %rax # imm = 0xFF00FF00FF00FF
andq %rax, %rsi
imulq %rsi, %rdx
movabsq $0x80008000800080, %rsi # imm = 0x80008000800080
addq %rdx, %rsi
shrq $0x8, %rdx
andq %rax, %rdx
addq %rdx, %rsi
shrq $0x8, %rsi
andq %rax, %rsi
movq %rsi, %rax
shrq $0x18, %rax
orl %esi, %eax
addl %ecx, %eax
movl %eax, %ecx
jmp 0x57042f
testq %r8, %r8
je 0x570219
movq %rdx, %rdi
shrq $0x30, %rdi
cmpl $0xffff, %edi # imm = 0xFFFF
jb 0x570225
movq (%r8), %rcx
testq %rcx, %rcx
je 0x570433
movd %eax, %xmm0
pxor %xmm1, %xmm1
movdqa %xmm0, %xmm2
punpcklbw %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
psllw $0x4, %xmm2
pextrw $0x2, %xmm2, %eax
punpcklbw %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
pextrw $0x0, %xmm2, %edi
pextrw $0x1, %xmm2, %r9d
pinsrw $0x0, (%rcx,%rax,2), %xmm1
pinsrw $0x1, (%rcx,%r9,2), %xmm1
pinsrw $0x2, (%rcx,%rdi,2), %xmm1
movdqa %xmm1, %xmm0
psrlw $0x8, %xmm0
paddw %xmm1, %xmm0
movq %rdx, %xmm1
movd %esi, %xmm2
punpcklbw %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0xc6, %xmm2, %xmm2 # xmm2 = xmm2[2,1,0,3,4,5,6,7]
movdqa %xmm2, %xmm3
pmullw %xmm1, %xmm3
pmulhuw %xmm2, %xmm1
punpcklwd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1],xmm3[2],xmm1[2],xmm3[3],xmm1[3]
pcmpeqd %xmm1, %xmm1
pxor %xmm2, %xmm1
movdqa %xmm0, %xmm2
pmullw %xmm1, %xmm2
pmulhuw %xmm0, %xmm1
punpcklwd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
paddd %xmm3, %xmm2
movdqa %xmm2, %xmm0
psrld $0x10, %xmm0
paddd %xmm2, %xmm0
paddd 0x2993f(%rip), %xmm0 # 0x599ab0
psrad $0x10, %xmm0
packssdw %xmm0, %xmm0
movq %xmm0, %rsi
jmp 0x570425
testl %ecx, %ecx
je 0x570431
movl %ecx, %ecx
movq %rcx, %rdi
shlq $0x18, %rdi
orq %rcx, %rdi
movabsq $0xff00ff00ff00ff, %rcx # imm = 0xFF00FF00FF00FF
andq %rcx, %rdi
movl %edx, %esi
imulq %rdi, %rsi
movq %rsi, %rdx
shrq $0x8, %rdx
andq %rcx, %rdx
movabsq $0x80008000800080, %rdi # imm = 0x80008000800080
addq %rdi, %rsi
addq %rdx, %rsi
movq %rsi, %r8
shrq $0x8, %r8
andq %rcx, %r8
movq %r8, %rdx
shrq $0x18, %rdx
orl %r8d, %edx
notq %rsi
shrq $0x38, %rsi
movq %rax, %r8
shlq $0x18, %r8
orq %rax, %r8
andq %rcx, %r8
imulq %rsi, %r8
movq %r8, %rax
shrq $0x8, %rax
andq %rcx, %rax
addq %rdi, %r8
addq %rax, %r8
shrq $0x8, %r8
andq %rcx, %r8
movq %r8, %rcx
shrq $0x18, %rcx
orl %r8d, %ecx
addl %edx, %ecx
jmp 0x57042f
cmpl $0xfeffffff, %ecx # imm = 0xFEFFFFFF
jbe 0x570238
movl %ecx, %edx
jmp 0x570289
cmpl $0xfeffffff, %ecx # imm = 0xFEFFFFFF
jbe 0x5702e0
movl %ecx, %edx
jmp 0x570331
movl %eax, %edx
testl %ecx, %ecx
je 0x570289
movl %ecx, %edx
notl %edx
shrl $0x18, %edx
movq %rax, %rdi
shlq $0x18, %rdi
orq %rax, %rdi
movabsq $0xff00ff00ff00ff, %r8 # imm = 0xFF00FF00FF00FF
andq %r8, %rdi
imulq %rdi, %rdx
movabsq $0x80008000800080, %rdi # imm = 0x80008000800080
addq %rdx, %rdi
shrq $0x8, %rdx
andq %r8, %rdx
addq %rdx, %rdi
shrq $0x8, %rdi
andq %r8, %rdi
movq %rdi, %rdx
shrq $0x18, %rdx
orl %edi, %edx
addl %ecx, %edx
movd %eax, %xmm0
movd %edx, %xmm1
movd %esi, %xmm2
pxor %xmm3, %xmm3
punpcklbw %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1],xmm1[2],xmm3[2],xmm1[3],xmm3[3],xmm1[4],xmm3[4],xmm1[5],xmm3[5],xmm1[6],xmm3[6],xmm1[7],xmm3[7]
punpcklbw %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1],xmm2[2],xmm3[2],xmm2[3],xmm3[3],xmm2[4],xmm3[4],xmm2[5],xmm3[5],xmm2[6],xmm3[6],xmm2[7],xmm3[7]
pmullw %xmm2, %xmm1
pxor 0x4e293(%rip), %xmm2 # 0x5be540
punpcklbw %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1],xmm0[2],xmm3[2],xmm0[3],xmm3[3],xmm0[4],xmm3[4],xmm0[5],xmm3[5],xmm0[6],xmm3[6],xmm0[7],xmm3[7]
pmullw %xmm0, %xmm2
paddw %xmm1, %xmm2
movdqa %xmm2, %xmm0
psrlw $0x8, %xmm0
paddw %xmm2, %xmm0
paddw 0x29542(%rip), %xmm0 # 0x599810
psrlw $0x8, %xmm0
packuswb %xmm0, %xmm0
movd %xmm0, %ecx
jmp 0x57042f
movl %eax, %edx
testl %ecx, %ecx
je 0x570331
movl %ecx, %edx
notl %edx
shrl $0x18, %edx
movq %rax, %rdi
shlq $0x18, %rdi
orq %rax, %rdi
movabsq $0xff00ff00ff00ff, %r9 # imm = 0xFF00FF00FF00FF
andq %r9, %rdi
imulq %rdi, %rdx
movabsq $0x80008000800080, %rdi # imm = 0x80008000800080
addq %rdx, %rdi
shrq $0x8, %rdx
andq %r9, %rdx
addq %rdx, %rdi
shrq $0x8, %rdi
andq %r9, %rdi
movq %rdi, %rdx
shrq $0x18, %rdx
orl %edi, %edx
addl %ecx, %edx
movq (%r8), %rcx
testq %rcx, %rcx
je 0x570438
movd %edx, %xmm1
pxor %xmm0, %xmm0
pxor %xmm2, %xmm2
punpcklbw %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
punpcklbw %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
psllw $0x4, %xmm1
pextrw $0x2, %xmm1, %edx
pextrw $0x0, %xmm1, %edi
pextrw $0x1, %xmm1, %r9d
pinsrw $0x0, (%rcx,%rdx,2), %xmm2
pinsrw $0x1, (%rcx,%r9,2), %xmm2
pinsrw $0x2, (%rcx,%rdi,2), %xmm2
movdqa %xmm2, %xmm1
psrlw $0x8, %xmm1
paddw %xmm2, %xmm1
movd %eax, %xmm2
movdqa %xmm2, %xmm3
punpcklbw %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3],xmm3[4],xmm0[4],xmm3[5],xmm0[5],xmm3[6],xmm0[6],xmm3[7],xmm0[7]
psllw $0x4, %xmm3
pextrw $0x2, %xmm3, %eax
punpcklbw %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1],xmm0[2],xmm2[2],xmm0[3],xmm2[3],xmm0[4],xmm2[4],xmm0[5],xmm2[5],xmm0[6],xmm2[6],xmm0[7],xmm2[7]
pextrw $0x0, %xmm3, %edx
pextrw $0x1, %xmm3, %edi
pinsrw $0x0, (%rcx,%rax,2), %xmm0
pinsrw $0x1, (%rcx,%rdi,2), %xmm0
pinsrw $0x2, (%rcx,%rdx,2), %xmm0
movdqa %xmm0, %xmm2
psrlw $0x8, %xmm2
paddw %xmm0, %xmm2
movd %esi, %xmm0
punpcklbw %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0xc6, %xmm0, %xmm0 # xmm0 = xmm0[2,1,0,3,4,5,6,7]
movdqa %xmm0, %xmm3
pmullw %xmm1, %xmm3
pmulhuw %xmm0, %xmm1
punpcklwd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1],xmm3[2],xmm1[2],xmm3[3],xmm1[3]
pcmpeqd %xmm1, %xmm1
pxor %xmm0, %xmm1
movdqa %xmm2, %xmm0
pmullw %xmm1, %xmm0
pmulhuw %xmm2, %xmm1
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
paddd %xmm3, %xmm0
movdqa %xmm0, %xmm1
psrld $0x10, %xmm1
paddd %xmm0, %xmm1
paddd 0x29699(%rip), %xmm1 # 0x599ab0
psrad $0x10, %xmm1
packssdw %xmm1, %xmm1
movq %xmm1, %rsi
movq %r8, %rdi
callq 0x5720be
movl %eax, %ecx
movl %ecx, (%rbx)
popq %rbx
retq
callq 0x16439a
callq 0x16437a
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
GradientBase32::fetchSingle(QGradientData const&, double) | static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
{
int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
return data->colorTable32[qt_gradient_clamp(data, ipos)];
} | endbr64
mulsd 0x2cc6e(%rip), %xmm0 # 0x59da48
addsd 0x3e6e(%rip), %xmm0 # 0x574c50
movq 0x40(%rdi), %rax
cvttsd2si %xmm0, %ecx
cmpl $0x400, %ecx # imm = 0x400
jb 0x570e26
movl (%rdi), %edx
cmpl $0x1, %edx
je 0x570e06
cmpl $0x2, %edx
jne 0x570e1a
andl $0x3ff, %ecx # imm = 0x3FF
jmp 0x570e26
movl $0x7ff, %edx # imm = 0x7FF
andl %edx, %ecx
xorl %ecx, %edx
cmpl $0x400, %ecx # imm = 0x400
cmovael %edx, %ecx
jmp 0x570e26
xorl %edx, %edx
testl %ecx, %ecx
movl $0x3ff, %ecx # imm = 0x3FF
cmovsl %edx, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
retq
| /qt[P]qtbase/src/gui/painting/qdrawhelper_p.h |
GradientBaseFP::fetchSingle(QGradientData const&, int) | static Type fetchSingle(const QGradientData& gradient, int v)
{
return qt_gradient_pixelFP_fixed(&gradient, v);
} | endbr64
movq 0x38(%rdi), %rax
subl $-0x80, %esi
sarl $0x8, %esi
cmpl $0x400, %esi # imm = 0x400
jb 0x570ed6
movl (%rdi), %ecx
cmpl $0x1, %ecx
je 0x570eb6
cmpl $0x2, %ecx
jne 0x570eca
andl $0x3ff, %esi # imm = 0x3FF
jmp 0x570ed6
movl $0x7ff, %ecx # imm = 0x7FF
andl %ecx, %esi
xorl %esi, %ecx
cmpl $0x400, %esi # imm = 0x400
cmovael %ecx, %esi
jmp 0x570ed6
xorl %ecx, %ecx
testl %esi, %esi
movl $0x3ff, %esi # imm = 0x3FF
cmovsl %ecx, %esi
movl %esi, %ecx
movq (%rax,%rcx,8), %xmm0
pxor %xmm1, %xmm1
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
cvtdq2ps %xmm0, %xmm0
mulps 0x5d391(%rip), %xmm0 # 0x5ce280
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
retq
nop
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void QThreadPool::start<void handleSpans<BlendSrcGenericRGB64>(int, QT_FT_Span_ const*, QSpanData const*, Operator const&)::'lambda'(), true>(void handleSpans<BlendSrcGenericRGB64>(int, QT_FT_Span_ const*, QSpanData const*, Operator const&)::'lambda'()&&, int) | void QThreadPool::start(Callable &&functionToRun, int priority)
{
start(QRunnable::create(std::forward<Callable>(functionToRun)), priority);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r12
movb $0x1, 0x8(%rax)
movq 0x17d890(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, (%r12)
movl $0x20, %edi
callq 0x1387d0
leaq 0x28d(%rip), %rcx # 0x571ad6
movq %rcx, (%rax)
movups (%r14), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r12)
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1393d0
nop
| /qt[P]qtbase/src/corelib/thread/qthreadpool.h |
void QThreadPool::start<void handleSpans<BlendSrcGenericRGBFP>(int, QT_FT_Span_ const*, QSpanData const*, Operator const&)::'lambda'(), true>(void handleSpans<BlendSrcGenericRGBFP>(int, QT_FT_Span_ const*, QSpanData const*, Operator const&)::'lambda'()&&, int) | void QThreadPool::start(Callable &&functionToRun, int priority)
{
start(QRunnable::create(std::forward<Callable>(functionToRun)), priority);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r12
movb $0x1, 0x8(%rax)
movq 0x17d36a(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, (%r12)
movl $0x20, %edi
callq 0x1387d0
leaq 0x28d(%rip), %rcx # 0x571ffc
movq %rcx, (%rax)
movups (%r14), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r12)
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1393d0
nop
| /qt[P]qtbase/src/corelib/thread/qthreadpool.h |
RadialFetchPlain<GradientBase32>::fetch(unsigned int*, unsigned int*, Operator const*, QSpanData const*, double, double, double, double, double) | static void fetch(BlendType *buffer, BlendType *end,
const Operator *op, const QSpanData *data, qreal det,
qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
{
if (op->radial.extended) {
while (buffer < end) {
BlendType result = GradientBase::null();
if (det >= 0) {
qreal w = qSqrt(det) - b;
if (data->gradient.radial.focal.radius + op->radial.dr * w >= 0)
result = GradientBase::fetchSingle(data->gradient, w);
}
*buffer = result;
det += delta_det;
delta_det += delta_delta_det;
b += delta_b;
++buffer;
}
} else {
while (buffer < end) {
BlendType result = GradientBase::null();
if (det >= 0) {
qreal w = qSqrt(det) - b;
result = GradientBase::fetchSingle(data->gradient, w);
}
*buffer++ = result;
det += delta_det;
delta_det += delta_delta_det;
b += delta_b;
}
}
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movapd %xmm0, %xmm6
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0xa8(%rdx)
movsd %xmm4, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
je 0x572231
cmpq %r14, %r15
jae 0x5722bc
movq %rdx, %r12
leaq 0xa8(%rbx), %r13
xorpd %xmm7, %xmm7
xorl %ebp, %ebp
ucomisd %xmm7, %xmm6
jb 0x572210
movsd %xmm3, (%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm6, 0x8(%rsp)
jb 0x57219b
xorps %xmm0, %xmm0
sqrtsd %xmm6, %xmm0
jmp 0x5721c5
movapd %xmm6, %xmm0
callq 0x13d230
xorpd %xmm7, %xmm7
movsd 0x8(%rsp), %xmm6
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd (%rsp), %xmm3
movsd 0x20(%rsp), %xmm4
subsd %xmm3, %xmm0
movsd 0x90(%r12), %xmm5
mulsd %xmm0, %xmm5
addsd 0xd8(%rbx), %xmm5
ucomisd %xmm7, %xmm5
jb 0x572210
movq %r13, %rdi
callq 0x570dce
xorpd %xmm7, %xmm7
movsd 0x8(%rsp), %xmm6
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd (%rsp), %xmm3
movsd 0x20(%rsp), %xmm4
movl %eax, %ebp
movl %ebp, (%r15)
addsd %xmm1, %xmm6
addsd %xmm2, %xmm1
addsd %xmm4, %xmm3
addq $0x4, %r15
cmpq %r14, %r15
jb 0x572173
jmp 0x5722bc
cmpq %r14, %r15
jae 0x5722bc
addq $0xa8, %rbx
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm6
jb 0x5722a4
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, (%rsp)
movsd %xmm6, 0x8(%rsp)
jb 0x572269
xorps %xmm0, %xmm0
sqrtsd %xmm6, %xmm0
jmp 0x572277
movapd %xmm6, %xmm0
callq 0x13d230
movsd (%rsp), %xmm3
subsd %xmm3, %xmm0
movq %rbx, %rdi
callq 0x570dce
movsd (%rsp), %xmm3
movsd 0x20(%rsp), %xmm4
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm6
xorpd %xmm0, %xmm0
movl %eax, (%r15)
addq $0x4, %r15
addsd %xmm1, %xmm6
addsd %xmm2, %xmm1
addsd %xmm4, %xmm3
cmpq %r14, %r15
jb 0x572245
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
RadialFetchPlain<GradientBase64>::fetch(QRgba64*, QRgba64*, Operator const*, QSpanData const*, double, double, double, double, double) | static void fetch(BlendType *buffer, BlendType *end,
const Operator *op, const QSpanData *data, qreal det,
qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
{
if (op->radial.extended) {
while (buffer < end) {
BlendType result = GradientBase::null();
if (det >= 0) {
qreal w = qSqrt(det) - b;
if (data->gradient.radial.focal.radius + op->radial.dr * w >= 0)
result = GradientBase::fetchSingle(data->gradient, w);
}
*buffer = result;
det += delta_det;
delta_det += delta_delta_det;
b += delta_b;
++buffer;
}
} else {
while (buffer < end) {
BlendType result = GradientBase::null();
if (det >= 0) {
qreal w = qSqrt(det) - b;
result = GradientBase::fetchSingle(data->gradient, w);
}
*buffer++ = result;
det += delta_det;
delta_det += delta_delta_det;
b += delta_b;
}
}
} | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0xa8(%rdx)
movsd %xmm4, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
je 0x5723b8
cmpq %r14, %r15
jae 0x572441
movq %rdx, %r12
leaq 0xa8(%rbx), %r13
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm0
jae 0x572320
xorl %eax, %eax
jmp 0x572397
movsd %xmm3, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
jb 0x57233a
sqrtsd %xmm0, %xmm0
jmp 0x572349
callq 0x13d230
xorpd %xmm5, %xmm5
movsd 0x8(%rsp), %xmm3
subsd %xmm3, %xmm0
movsd 0x90(%r12), %xmm1
mulsd %xmm0, %xmm1
addsd 0xd8(%rbx), %xmm1
ucomisd %xmm5, %xmm1
jae 0x57236d
xorl %eax, %eax
jmp 0x57237f
movq %r13, %rdi
callq 0x570e2c
xorpd %xmm5, %xmm5
movsd 0x8(%rsp), %xmm3
movsd 0x28(%rsp), %xmm4
movsd 0x20(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
movq %rax, (%r15)
addsd %xmm1, %xmm0
addsd %xmm2, %xmm1
addsd %xmm4, %xmm3
addq $0x8, %r15
cmpq %r14, %r15
jb 0x572316
jmp 0x572441
cmpq %r14, %r15
jae 0x572441
addq $0xa8, %rbx
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm0
jae 0x5723d6
xorl %eax, %eax
jmp 0x572429
movsd %xmm1, 0x18(%rsp)
movsd %xmm3, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
jb 0x5723f0
sqrtsd %xmm0, %xmm0
jmp 0x5723fb
callq 0x13d230
movsd 0x8(%rsp), %xmm3
subsd %xmm3, %xmm0
movq %rbx, %rdi
callq 0x570e2c
movsd 0x8(%rsp), %xmm3
movsd 0x28(%rsp), %xmm4
movsd 0x20(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
xorpd %xmm5, %xmm5
movq %rax, (%r15)
addq $0x8, %r15
addsd %xmm1, %xmm0
addsd %xmm2, %xmm1
addsd %xmm4, %xmm3
cmpq %r14, %r15
jb 0x5723cc
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
QEdidParser::parseEdidString(unsigned char const*) | QString QEdidParser::parseEdidString(const quint8 *data)
{
QByteArray buffer(reinterpret_cast<const char *>(data), 13);
for (int i = 0; i < buffer.size(); ++i) {
// If there are less than 13 characters in the string, the string
// is terminated with the ASCII code ‘0Ah’ (line feed) and padded
// with ASCII code ‘20h’ (space). See EDID 1.4, sections 3.10.3.1,
// 3.10.3.2, and 3.10.3.4.
if (buffer[i] == '\n') {
buffer.truncate(i);
break;
}
// Replace non-printable characters with dash
if (buffer[i] < '\040' || buffer[i] > '\176')
buffer[i] = '-';
}
return QString::fromLatin1(buffer);
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rsi
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r14
movq %rax, 0x10(%r14)
movaps 0x1671(%rip), %xmm0 # 0x574680
movaps %xmm0, (%r14)
movl $0xd, %edx
movq %r14, %rdi
callq 0x144940
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x573101
xorl %r14d, %r14d
movq %rsp, %r15
movq (%rsp), %rax
testq %rax, %rax
je 0x573043
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x573050
movq %r15, %rdi
movl $0x1, %edx
callq 0x144b20
movq 0x8(%rsp), %rax
movb (%rax,%r14), %cl
cmpb $0xa, %cl
je 0x573105
movq (%rsp), %rdx
testq %rdx, %rdx
je 0x573072
movl (%rdx), %esi
cmpl $0x2, %esi
jl 0x573091
movq 0x10(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x144b20
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movb (%rax,%r14), %cl
cmpb $0x20, %cl
jl 0x5730c6
testq %rdx, %rdx
je 0x5730a2
movl (%rdx), %edx
cmpl $0x2, %edx
jl 0x5730bd
movq 0x10(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x144b20
movq 0x8(%rsp), %rax
movb (%rax,%r14), %cl
cmpb $0x7f, %cl
jne 0x5730ee
movq (%rsp), %rdx
testq %rdx, %rdx
je 0x5730d2
movl (%rdx), %ecx
cmpl $0x2, %ecx
jl 0x5730e9
movq 0x10(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x144b20
movq 0x8(%rsp), %rax
movb $0x2d, (%rax,%r14)
incq %r14
movq 0x10(%rsp), %rsi
cmpq %r14, %rsi
ja 0x573033
jmp 0x573117
xorl %esi, %esi
jmp 0x573117
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x149230
movq 0x10(%r15), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x143140
movq (%rsp), %rax
testq %rax, %rax
je 0x573145
lock
decl (%rax)
jne 0x573145
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x573162
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/util/qedidparser.cpp |
QList<unsigned short>::reserve(long long) | void QList<T>::reserve(qsizetype asize)
{
// capacity() == 0 for immutable data, so this will force a detaching below
if (asize <= capacity() - d.freeSpaceAtBegin()) {
if (d->flags() & Data::CapacityReserved)
return; // already reserved, don't shrink
if (!d->isShared()) {
// 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movq (%rdi), %rax
testq %rax, %rax
je 0x5731ae
movq 0x8(%rax), %rcx
movq 0x8(%rbx), %rdx
leaq 0x1f(%rax), %rdi
andq $-0x10, %rdi
subq %rdi, %rdx
sarq %rdx
subq %rdx, %rcx
cmpq %rsi, %rcx
jge 0x57322b
movq 0x10(%rbx), %rax
cmpq %rsi, %rax
cmovgq %rax, %rsi
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r15, %rdi
movl $0x1, %edx
callq 0x13ccf0
movq %rax, %r14
movq (%r15), %r12
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x5731f7
movq 0x8(%rbx), %rsi
leaq (%r15,%r15), %rdx
movq %r14, %rdi
callq 0x137aa0
testq %r12, %r12
je 0x573202
orb $0x1, 0x4(%r12)
movq (%rbx), %rdi
movq %r12, (%rbx)
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
testq %rdi, %rdi
je 0x573244
lock
decl (%rdi)
jne 0x573244
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x573244
movl 0x4(%rax), %ecx
testb $0x1, %cl
jne 0x573244
movl (%rax), %edx
cmpl $0x1, %edx
jne 0x5731ae
orl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x573260
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
void QtPrivate::QMovableArrayOps<QList<unsigned short>>::emplace<QList<unsigned short> const&>(long long, QList<unsigned short> const&) | void emplace(qsizetype i, Args &&... args)
{
bool detach = this->needsDetach();
if (!detach) {
if (i == this->size && this->freeSpaceAtEnd()) {
new (this->end()) T(std::forward<Args>(args)...);
++this->size;
return;
}
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)...);
const bool growsAtBegin = this->size != 0 && i == 0;
const auto pos = growsAtBegin ? Data::GrowsAtBeginning : Data::GrowsAtEnd;
this->detachAndGrow(pos, 1, nullptr, nullptr);
if (growsAtBegin) {
Q_ASSERT(this->freeSpaceAtBegin());
new (this->begin() - 1) T(std::move(tmp));
--this->ptr;
++this->size;
} else {
Inserter(this, i, 1).insertOne(std::move(tmp));
}
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x5732e5
movl (%rcx), %eax
cmpl $0x1, %eax
jg 0x5732e5
leaq 0x10(%r14), %r12
movq 0x10(%r14), %rax
cmpq %rbx, %rax
jne 0x5732cb
movq 0x8(%rcx), %rdi
movq 0x8(%r14), %rsi
leaq 0x1f(%rcx), %r8
andq $-0x10, %r8
movq %rsi, %r9
subq %r8, %r9
sarq $0x3, %r9
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r9, %r8
subq %rbx, %rdi
cmpq %r8, %rdi
jne 0x5733a1
testq %rbx, %rbx
jne 0x5732e5
movq 0x8(%r14), %rsi
addq $0x1f, %rcx
andq $-0x10, %rcx
cmpq %rsi, %rcx
jne 0x5733c8
movq (%rdx), %r15
movq 0x8(%rdx), %r13
movq 0x10(%rdx), %rax
movq %rax, (%rsp)
testq %r15, %r15
je 0x5732fd
lock
incl (%r15)
leaq 0x10(%r14), %r12
cmpq $0x0, 0x10(%r14)
setne %al
testq %rbx, %rbx
sete %cl
andb %al, %cl
movzbl %cl, %ebp
movl $0x1, %edx
movq %r14, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x573434
movq 0x8(%r14), %rax
cmpb $0x1, %bpl
jne 0x573350
leaq -0x18(%rax), %rcx
movq %r15, -0x18(%rax)
movq %r13, -0x10(%rax)
movq (%rsp), %rdx
movq %rdx, -0x8(%rax)
movq %rcx, 0x8(%r14)
movq 0x10(%r14), %rbx
jmp 0x57338b
leaq (%rbx,%rbx,2), %rcx
leaq (%rax,%rcx,8), %rsi
leaq (%rax,%rcx,8), %r14
addq $0x18, %r14
movq (%r12), %rax
subq %rbx, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
movq %r14, %rdi
callq 0x138810
movq %r15, -0x18(%r14)
movq %r13, -0x10(%r14)
movq (%rsp), %rax
movq %rax, -0x8(%r14)
movq (%r12), %rbx
incq %rbx
movq %rbx, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%rbx,%rbx,2), %rcx
movq (%rdx), %rax
movq %rax, (%rsi,%rcx,8)
movq 0x8(%rdx), %rdi
movq %rdi, 0x8(%rsi,%rcx,8)
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rsi,%rcx,8)
testq %rax, %rax
je 0x57338b
lock
incl (%rax)
jmp 0x573387
movq (%rdx), %rcx
movq %rcx, -0x18(%rsi)
movq 0x8(%rdx), %rdi
movq %rdi, -0x10(%rsi)
movq 0x10(%rdx), %rdx
movq %rdx, -0x8(%rsi)
testq %rcx, %rcx
je 0x5733ef
lock
incl (%rcx)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
addq $-0x18, %rsi
movq %rsi, 0x8(%r14)
movq %rax, %rbx
jmp 0x57338b
| /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QArrayDataPointer<QList<unsigned short>>::detachAndGrow(QArrayData::GrowthPosition, long long, QList<unsigned short> const**, QArrayDataPointer<QList<unsigned short>>*) | void detachAndGrow(QArrayData::GrowthPosition where, qsizetype n, const T **data,
QArrayDataPointer *old)
{
const bool detach = needsDetach();
bool readjusted = false;
if (!detach) {
if (!n || (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= 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 0x573459
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x573473
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5735c2
testq %r14, %r14
je 0x5734f4
testl %ebp, %ebp
je 0x5734ae
cmpl $0x1, %ebp
jne 0x5734a7
movq 0x8(%r15), %rdx
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rax
cmpq %r14, %rax
jge 0x5734f4
movq %r15, %rdi
movl %ebp, %esi
jmp 0x5734e4
movq 0x8(%rax), %rdx
movq 0x8(%r15), %rsi
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rsi
sarq $0x3, %rsi
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
imulq %rsi, %rax
subq 0x10(%r15), %rdx
addq %rax, %rdx
cmpq %r14, %rdx
jge 0x5734f4
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x573500
testb %al, %al
je 0x573459
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QList<unsigned short>>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<QList<unsigned short>>*) | Q_NEVER_INLINE void reallocateAndGrow(QArrayData::GrowthPosition where, qsizetype n,
QArrayDataPointer *old = nullptr)
{
if constexpr (QTypeInfo<T>::isRelocatable && alignof(T) <= alignof(std::max_align_t)) {
if (where == QArrayData::GrowsAtEnd && !old && !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 0x573652
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x573652
movl (%rdi), %eax
testq %r15, %r15
jle 0x573652
cmpl $0x1, %eax
jg 0x573652
movq 0x8(%rbx), %rsi
leaq 0x1f(%rdi), %rax
andq $-0x10, %rax
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
addq 0x10(%rbx), %r15
addq %rax, %r15
movl $0x18, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149770
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
jmp 0x5737b7
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movaps 0x1016(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rdi)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x57386c
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x573765
movq %r15, %rcx
sarq $0x3f, %rcx
andq %r15, %rcx
addq %rcx, %rax
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x57370d
movl (%rcx), %ecx
testq %r14, %r14
jne 0x57370d
cmpl $0x2, %ecx
jge 0x57370d
testq %rax, %rax
je 0x573765
jle 0x573765
movq 0x8(%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rdi
xorl %esi, %esi
leaq (%rdi,%rdi,2), %rdi
movq (%rcx), %r8
movq %rsi, (%rcx)
movq %r8, (%rdx,%rdi,8)
movq 0x8(%rcx), %r8
movq %rsi, 0x8(%rcx)
movq %r8, 0x8(%rdx,%rdi,8)
movq 0x10(%rcx), %r8
movq %rsi, 0x10(%rcx)
movq %r8, 0x10(%rdx,%rdi,8)
addq $0x18, %rcx
movq 0x10(%rsp), %rdi
incq %rdi
movq %rdi, 0x10(%rsp)
cmpq %rax, %rcx
jb 0x5736cd
jmp 0x573765
testq %rax, %rax
je 0x573765
jle 0x573765
movq 0x8(%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
leaq (%rsi,%rsi,2), %r8
movq (%rcx), %rdi
movq %rdi, (%rdx,%r8,8)
movq 0x8(%rcx), %r9
movq %r9, 0x8(%rdx,%r8,8)
movq 0x10(%rcx), %r9
movq %r9, 0x10(%rdx,%r8,8)
testq %rdi, %rdi
je 0x573754
lock
incl (%rdi)
movq 0x10(%rsp), %rsi
addq $0x18, %rcx
incq %rsi
movq %rsi, 0x10(%rsp)
cmpq %rax, %rcx
jb 0x57372a
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 0x5737af
movups (%r14), %xmm0
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
movaps %xmm0, (%rsp)
movq 0x10(%r14), %rax
movq %rdx, 0x10(%r14)
movq %rax, 0x10(%rsp)
movq %rsp, %rdi
callq 0x5739f0
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x5737d1
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.