name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
tcu::Matrix<float, 3, 4> deqp::gles3::Functional::MatrixCaseUtils::matrixCompMult<float, 3, 4>(tcu::Matrix<float, 3, 4> const&, tcu::Matrix<float, 3, 4> const&) | tcu::Matrix<T, Rows, Cols> matrixCompMult (const tcu::Matrix<T, Rows, Cols>& a, const tcu::Matrix<T, Rows, Cols>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a(r,c) * b(r, c);
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655e84(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a5e30
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0xc, %r10
cmpq $0x30, %r10
jne 0x3a5e25
incq %r9
addq $0x4, %r8
addq $0xc, %rcx
cmpq $0x3, %r9
jne 0x3a5e22
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8), %xmm0
mulss (%rdx,%r8), %xmm0
movss %xmm0, (%rdi,%r8)
addq $0xc, %r8
cmpq $0x30, %r8
jne 0x3a5e56
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdx
addq $0x4, %rdi
cmpq $0x3, %rcx
jne 0x3a5e53
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 3, 3> tcu::operator*<float, 3, 4, 4, 3>(tcu::Matrix<float, 3, 4> const&, tcu::Matrix<float, 4, 3> const&) | Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x0, 0x20(%rdi)
xorl %ecx, %ecx
movss 0x655d54(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a5f5d
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0xc, %r9
cmpq $0x24, %r9
jne 0x3a5f52
incq %r8
addq $0x4, %rdi
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a5f4f
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
movq %rsi, %r10
xorl %r11d, %r11d
movss (%r10), %xmm1
mulss (%r8,%r11,4), %xmm1
addss %xmm1, %xmm0
incq %r11
addq $0xc, %r10
cmpq $0x4, %r11
jne 0x3a5f93
leaq (%r9,%r9,2), %r10
movss %xmm0, (%rdi,%r10,4)
incq %r9
addq $0x10, %r8
cmpq $0x3, %r9
jne 0x3a5f8a
incq %rcx
addq $0x4, %rsi
cmpq $0x3, %rcx
jne 0x3a5f80
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp |
tcu::Matrix<float, 3, 4> tcu::operator*<float, 3, 4, 4, 4>(tcu::Matrix<float, 3, 4> const&, tcu::Matrix<float, 4, 4> const&) | Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655cb1(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a6000
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0xc, %r9
cmpq $0x30, %r9
jne 0x3a5ff5
incq %r8
addq $0x4, %rdi
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a5ff2
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
movq %rsi, %r10
xorl %r11d, %r11d
movss (%r10), %xmm1
mulss (%r8,%r11,4), %xmm1
addss %xmm1, %xmm0
incq %r11
addq $0xc, %r10
cmpq $0x4, %r11
jne 0x3a6036
leaq (%r9,%r9,2), %r10
movss %xmm0, (%rdi,%r10,4)
incq %r9
addq $0x10, %r8
cmpq $0x4, %r9
jne 0x3a602d
incq %rcx
addq $0x4, %rsi
cmpq $0x3, %rcx
jne 0x3a6023
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp |
tcu::Matrix<float, 4, 4> tcu::operator+<float, 4, 4>(tcu::Matrix<float, 4, 4> const&, tcu::Matrix<float, 4, 4> const&) | Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) + b(row, col);
return res;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655c0a(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a60aa
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0x10, %r10
cmpq $0x40, %r10
jne 0x3a609f
incq %r9
addq $0x4, %r8
addq $0x10, %rcx
cmpq $0x4, %r9
jne 0x3a609c
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
addss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x4, %r8
jne 0x3a60d0
incq %rcx
addq $0x10, %rdi
addq $0x10, %rdx
addq $0x10, %rsi
cmpq $0x4, %rcx
jne 0x3a60cd
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp |
tcu::Matrix<float, 4, 4> tcu::operator-<float, 4, 4>(tcu::Matrix<float, 4, 4> const&, tcu::Matrix<float, 4, 4> const&) | Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) - b(row, col);
return res;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655b80(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a6134
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0x10, %r10
cmpq $0x40, %r10
jne 0x3a6129
incq %r9
addq $0x4, %r8
addq $0x10, %rcx
cmpq $0x4, %r9
jne 0x3a6126
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
subss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x4, %r8
jne 0x3a615a
incq %rcx
addq $0x10, %rdi
addq $0x10, %rdx
addq $0x10, %rsi
cmpq $0x4, %rcx
jne 0x3a6157
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp |
tcu::Matrix<float, 4, 4> tcu::operator/<float, 4, 4>(tcu::Matrix<float, 4, 4> const&, tcu::Matrix<float, 4, 4> const&) | Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) / b(row, col);
return res;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655af6(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a61be
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0x10, %r10
cmpq $0x40, %r10
jne 0x3a61b3
incq %r9
addq $0x4, %r8
addq $0x10, %rcx
cmpq $0x4, %r9
jne 0x3a61b0
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
divss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x4, %r8
jne 0x3a61e4
incq %rcx
addq $0x10, %rdi
addq $0x10, %rdx
addq $0x10, %rsi
cmpq $0x4, %rcx
jne 0x3a61e1
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp |
tcu::Matrix<float, 4, 4> deqp::gles3::Functional::MatrixCaseUtils::matrixCompMult<float, 4, 4>(tcu::Matrix<float, 4, 4> const&, tcu::Matrix<float, 4, 4> const&) | tcu::Matrix<T, Rows, Cols> matrixCompMult (const tcu::Matrix<T, Rows, Cols>& a, const tcu::Matrix<T, Rows, Cols>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a(r,c) * b(r, c);
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655a6c(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a6248
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0x10, %r10
cmpq $0x40, %r10
jne 0x3a623d
incq %r9
addq $0x4, %r8
addq $0x10, %rcx
cmpq $0x4, %r9
jne 0x3a623a
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8), %xmm0
mulss (%rdx,%r8), %xmm0
movss %xmm0, (%rdi,%r8)
addq $0x10, %r8
cmpq $0x40, %r8
jne 0x3a626e
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdx
addq $0x4, %rdi
cmpq $0x4, %rcx
jne 0x3a626b
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 4, 2> tcu::operator*<float, 4, 4, 4, 2>(tcu::Matrix<float, 4, 4> const&, tcu::Matrix<float, 4, 2> const&) | Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x6559e9(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a62c8
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0x10, %r9
cmpq $0x10, %r9
je 0x3a62bd
incq %r8
addq $0x4, %rdi
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a62ba
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss (%r8,%r10), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
cmpq $0x10, %r10
jne 0x3a62fb
movq %r9, %r10
shlq $0x4, %r10
movss %xmm0, (%rdi,%r10)
leaq 0x1(%r9), %r10
addq $0x10, %r8
testq %r9, %r9
movq %r10, %r9
je 0x3a62f5
incq %rcx
addq $0x4, %rsi
cmpq $0x4, %rcx
jne 0x3a62eb
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp |
tcu::Matrix<float, 4, 3> tcu::operator*<float, 4, 4, 4, 3>(tcu::Matrix<float, 4, 4> const&, tcu::Matrix<float, 4, 3> const&) | Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655945(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a636c
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a6361
incq %r8
addq $0x4, %rdi
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a635e
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss (%r8,%r10), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
cmpq $0x10, %r10
jne 0x3a639f
movq %r9, %r10
shlq $0x4, %r10
movss %xmm0, (%rdi,%r10)
incq %r9
addq $0x10, %r8
cmpq $0x3, %r9
jne 0x3a6399
incq %rcx
addq $0x4, %rsi
cmpq $0x4, %rcx
jne 0x3a638f
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp |
tcu::Matrix<float, 2, 2> deqp::gles3::Functional::MatrixCaseUtils::outerProduct<float, 2, 2>(tcu::Vector<float, 2> const&, tcu::Vector<float, 2> const&) | tcu::Matrix<T, Cols, Rows> outerProduct (const tcu::Vector<T, Cols>& a, const tcu::Vector<T, Rows>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a[c] * b[r];
return transpose(retVal); // to gl-form (column-major)
} | movq %rdi, %rax
xorps %xmm0, %xmm0
leaq -0x18(%rsp), %rcx
movaps %xmm0, (%rcx)
xorl %r8d, %r8d
movss 0x655801(%rip), %xmm0 # 0x9fbca0
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %r8
je 0x3a64ad
xorps %xmm1, %xmm1
movss %xmm1, (%rcx,%r9,8)
incq %r9
cmpq $0x1, %r9
je 0x3a64a2
leaq 0x1(%r8), %r9
addq $0x4, %rcx
testq %r8, %r8
movq %r9, %r8
je 0x3a649f
leaq -0x18(%rsp), %rcx
xorl %r8d, %r8d
movss (%rdx,%r8,4), %xmm0
xorl %r9d, %r9d
movss (%rsi,%r9,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rcx,%r9,8)
incq %r9
cmpq $0x1, %r9
je 0x3a64dd
leaq 0x1(%r8), %r9
addq $0x4, %rcx
testq %r8, %r8
movq %r9, %r8
je 0x3a64d4
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x65578a(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x3a6526
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x3a651b
leaq 0x1(%rcx), %rsi
addq $0x4, %rdx
testq %rcx, %rcx
movq %rsi, %rcx
je 0x3a6519
leaq -0x18(%rsp), %rcx
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,8), %xmm0
movss %xmm0, (%rdi,%rsi,4)
incq %rsi
cmpq $0x1, %rsi
je 0x3a654d
leaq 0x1(%rdx), %rsi
addq $0x8, %rdi
addq $0x4, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x3a654b
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 2, 3> deqp::gles3::Functional::MatrixCaseUtils::outerProduct<float, 3, 2>(tcu::Vector<float, 2> const&, tcu::Vector<float, 3> const&) | tcu::Matrix<T, Cols, Rows> outerProduct (const tcu::Vector<T, Cols>& a, const tcu::Vector<T, Rows>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a[c] * b[r];
return transpose(retVal); // to gl-form (column-major)
} | movq %rdi, %rax
xorps %xmm0, %xmm0
leaq -0x18(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
xorl %r8d, %r8d
movss 0x65570a(%rip), %xmm0 # 0x9fbca0
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %r8
je 0x3a65a7
xorps %xmm1, %xmm1
movss %xmm1, (%rcx,%r10)
addq $0xc, %r10
cmpq $0xc, %r10
je 0x3a659c
incq %r9
addq $0x4, %rcx
addq $0xc, %r8
cmpq $0x3, %r9
jne 0x3a6599
leaq -0x18(%rsp), %rcx
xorl %r8d, %r8d
movss (%rdx,%r8,4), %xmm0
movq %rcx, %r9
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%r9)
incq %r10
addq $0xc, %r9
cmpq $0x1, %r10
je 0x3a65dc
incq %r8
addq $0x4, %rcx
cmpq $0x3, %r8
jne 0x3a65d0
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x655683(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x3a662d
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x3a6622
leaq 0x1(%rcx), %rsi
addq $0x4, %rdx
testq %rcx, %rcx
movq %rsi, %rcx
je 0x3a6620
leaq -0x18(%rsp), %rcx
xorl %edx, %edx
movq %rcx, %rsi
xorl %r8d, %r8d
movss (%rsi), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
addq $0xc, %rsi
cmpq $0x1, %r8
je 0x3a6658
incq %rdx
addq $0x8, %rdi
addq $0x4, %rcx
cmpq $0x3, %rdx
jne 0x3a6652
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 2, 4> deqp::gles3::Functional::MatrixCaseUtils::outerProduct<float, 4, 2>(tcu::Vector<float, 2> const&, tcu::Vector<float, 4> const&) | tcu::Matrix<T, Cols, Rows> outerProduct (const tcu::Vector<T, Cols>& a, const tcu::Vector<T, Rows>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a[c] * b[r];
return transpose(retVal); // to gl-form (column-major)
} | movq %rdi, %rax
xorps %xmm0, %xmm0
leaq -0x28(%rsp), %rcx
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
xorl %r8d, %r8d
movss 0x655602(%rip), %xmm0 # 0x9fbca0
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %r8
je 0x3a66af
xorps %xmm1, %xmm1
movss %xmm1, (%rcx,%r10)
addq $0x10, %r10
cmpq $0x10, %r10
je 0x3a66a4
incq %r9
addq $0x4, %rcx
addq $0x10, %r8
cmpq $0x4, %r9
jne 0x3a66a1
leaq -0x28(%rsp), %rcx
xorl %r8d, %r8d
movss (%rdx,%r8,4), %xmm0
xorl %r9d, %r9d
movss (%rsi,%r9), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rcx,%r9,4)
addq $0x4, %r9
cmpq $0x4, %r9
je 0x3a66e1
incq %r8
addq $0x4, %rcx
cmpq $0x4, %r8
jne 0x3a66d8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655584(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x3a672c
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq $0x4, %rsi
jne 0x3a6721
leaq 0x1(%rcx), %rsi
addq $0x4, %rdx
testq %rcx, %rcx
movq %rsi, %rcx
je 0x3a671f
leaq -0x28(%rsp), %rcx
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rdi,%rsi)
addq $0x4, %rsi
cmpq $0x4, %rsi
je 0x3a6753
incq %rdx
addq $0x8, %rdi
addq $0x4, %rcx
cmpq $0x4, %rdx
jne 0x3a6751
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 3, 2> deqp::gles3::Functional::MatrixCaseUtils::outerProduct<float, 2, 3>(tcu::Vector<float, 3> const&, tcu::Vector<float, 2> const&) | tcu::Matrix<T, Cols, Rows> outerProduct (const tcu::Vector<T, Cols>& a, const tcu::Vector<T, Rows>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a[c] * b[r];
return transpose(retVal); // to gl-form (column-major)
} | movq %rdi, %rax
xorps %xmm0, %xmm0
leaq -0x18(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
xorl %r8d, %r8d
movss 0x655506(%rip), %xmm0 # 0x9fbca0
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %r8
je 0x3a67a8
xorps %xmm1, %xmm1
movss %xmm1, (%rcx,%r9,8)
incq %r9
cmpq $0x3, %r9
jne 0x3a679d
leaq 0x1(%r8), %r9
addq $0x4, %rcx
testq %r8, %r8
movq %r9, %r8
je 0x3a679a
leaq -0x18(%rsp), %rcx
xorl %r8d, %r8d
movss (%rdx,%r8,4), %xmm0
xorl %r9d, %r9d
movss (%rsi,%r9,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rcx,%r9,8)
incq %r9
cmpq $0x3, %r9
jne 0x3a67d8
leaq 0x1(%r8), %r9
addq $0x4, %rcx
testq %r8, %r8
movq %r9, %r8
je 0x3a67cf
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x655487(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %esi, %esi
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a682c
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r8)
addq $0xc, %r8
cmpq $0xc, %r8
je 0x3a6821
incq %rsi
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x3a681e
leaq -0x18(%rsp), %rcx
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,8), %xmm0
movss %xmm0, (%rdi,%rsi,4)
incq %rsi
cmpq $0x3, %rsi
jne 0x3a6856
leaq 0x1(%rdx), %rsi
addq $0xc, %rdi
addq $0x4, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x3a6854
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 3, 3> deqp::gles3::Functional::MatrixCaseUtils::outerProduct<float, 3, 3>(tcu::Vector<float, 3> const&, tcu::Vector<float, 3> const&) | tcu::Matrix<T, Cols, Rows> outerProduct (const tcu::Vector<T, Cols>& a, const tcu::Vector<T, Rows>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a[c] * b[r];
return transpose(retVal); // to gl-form (column-major)
} | movq %rdi, %rax
xorps %xmm0, %xmm0
leaq -0x28(%rsp), %rcx
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movl $0x0, 0x20(%rcx)
xorl %r8d, %r8d
movss 0x6553fe(%rip), %xmm0 # 0x9fbca0
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %r8
je 0x3a68b3
xorps %xmm1, %xmm1
movss %xmm1, (%rcx,%r10)
addq $0xc, %r10
cmpq $0x24, %r10
jne 0x3a68a8
incq %r9
addq $0x4, %rcx
addq $0xc, %r8
cmpq $0x3, %r9
jne 0x3a68a5
leaq -0x28(%rsp), %rcx
xorl %r8d, %r8d
movss (%rdx,%r8,4), %xmm0
movq %rcx, %r9
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%r9)
incq %r10
addq $0xc, %r9
cmpq $0x3, %r10
jne 0x3a68e8
incq %r8
addq $0x4, %rcx
cmpq $0x3, %r8
jne 0x3a68dc
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x0, 0x20(%rdi)
xorl %ecx, %ecx
movss 0x655374(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %esi, %esi
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a693f
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r8)
addq $0xc, %r8
cmpq $0x24, %r8
jne 0x3a6934
incq %rsi
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x3a6931
leaq -0x28(%rsp), %rcx
xorl %edx, %edx
movq %rcx, %rsi
xorl %r8d, %r8d
movss (%rsi), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
addq $0xc, %rsi
cmpq $0x3, %r8
jne 0x3a696d
incq %rdx
addq $0xc, %rdi
addq $0x4, %rcx
cmpq $0x3, %rdx
jne 0x3a6967
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 2, 2> deqp::gles3::Functional::MatrixCaseUtils::negate<float, 2, 2>(tcu::Matrix<float, 2, 2> const&) | tcu::Matrix<T, Rows, Cols> negate (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = -mat(r, c);
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x654ed4(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a6ddd
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r8,8)
incq %r8
cmpq $0x1, %r8
je 0x3a6dd2
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a6dcf
xorl %ecx, %ecx
movaps 0x65a0cb(%rip), %xmm0 # 0xa00ed0
xorl %edx, %edx
movss (%rsi,%rdx,8), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,8)
incq %rdx
cmpq $0x1, %rdx
je 0x3a6e07
leaq 0x1(%rcx), %rdx
addq $0x4, %rsi
addq $0x4, %rdi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a6e05
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 2, 2> deqp::gles3::Functional::MatrixCaseUtils::increment<float, 2, 2>(tcu::Matrix<float, 2, 2> const&) | tcu::Matrix<T, Rows, Cols> increment (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) + 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x654e5b(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a6e56
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r8,8)
incq %r8
cmpq $0x1, %r8
je 0x3a6e4b
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a6e48
xorl %ecx, %ecx
movss 0x654e21(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movss (%rsi,%rdx,8), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,8)
incq %rdx
cmpq $0x1, %rdx
je 0x3a6e81
leaq 0x1(%rcx), %rdx
addq $0x4, %rsi
addq $0x4, %rdi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a6e7f
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 2, 2> deqp::gles3::Functional::MatrixCaseUtils::decrement<float, 2, 2>(tcu::Matrix<float, 2, 2> const&) | tcu::Matrix<T, Rows, Cols> decrement (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) - 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x654de0(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a6ed1
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r8,8)
incq %r8
cmpq $0x1, %r8
je 0x3a6ec6
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a6ec3
xorl %ecx, %ecx
movss 0x65ac72(%rip), %xmm0 # 0xa01b6c
xorl %edx, %edx
movss (%rsi,%rdx,8), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,8)
incq %rdx
cmpq $0x1, %rdx
je 0x3a6efc
leaq 0x1(%rcx), %rdx
addq $0x4, %rsi
addq $0x4, %rdi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a6efa
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 3, 2> deqp::gles3::Functional::MatrixCaseUtils::negate<float, 3, 2>(tcu::Matrix<float, 3, 2> const&) | tcu::Matrix<T, Rows, Cols> negate (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = -mat(r, c);
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x654d5d(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a6f57
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r9)
addq $0xc, %r9
cmpq $0xc, %r9
je 0x3a6f4c
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a6f49
xorl %ecx, %ecx
movaps 0x659f4f(%rip), %xmm0 # 0xa00ed0
xorl %edx, %edx
movss (%rsi,%rdx), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx)
addq $0xc, %rdx
cmpq $0xc, %rdx
je 0x3a6f83
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x3, %rcx
jne 0x3a6f81
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 3, 2> deqp::gles3::Functional::MatrixCaseUtils::increment<float, 3, 2>(tcu::Matrix<float, 3, 2> const&) | tcu::Matrix<T, Rows, Cols> increment (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) + 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x654cd9(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a6fdb
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r9)
addq $0xc, %r9
cmpq $0xc, %r9
je 0x3a6fd0
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a6fcd
xorl %ecx, %ecx
movss 0x654c9a(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movss (%rsi,%rdx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx)
addq $0xc, %rdx
cmpq $0xc, %rdx
je 0x3a7008
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x3, %rcx
jne 0x3a7006
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 3, 2> deqp::gles3::Functional::MatrixCaseUtils::decrement<float, 3, 2>(tcu::Matrix<float, 3, 2> const&) | tcu::Matrix<T, Rows, Cols> decrement (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) - 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x654c53(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a7061
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r9)
addq $0xc, %r9
cmpq $0xc, %r9
je 0x3a7056
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a7053
xorl %ecx, %ecx
movss 0x65aae0(%rip), %xmm0 # 0xa01b6c
xorl %edx, %edx
movss (%rsi,%rdx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx)
addq $0xc, %rdx
cmpq $0xc, %rdx
je 0x3a708e
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x3, %rcx
jne 0x3a708c
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 4, 2> deqp::gles3::Functional::MatrixCaseUtils::negate<float, 4, 2>(tcu::Matrix<float, 4, 2> const&) | tcu::Matrix<T, Rows, Cols> negate (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = -mat(r, c);
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x654bd1(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a70e3
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x10, %r9
je 0x3a70d8
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a70d5
xorl %ecx, %ecx
movaps 0x659dc3(%rip), %xmm0 # 0xa00ed0
xorl %edx, %edx
movss (%rsi,%rdx), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx)
addq $0x10, %rdx
cmpq $0x10, %rdx
je 0x3a710f
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x4, %rcx
jne 0x3a710d
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 4, 2> deqp::gles3::Functional::MatrixCaseUtils::increment<float, 4, 2>(tcu::Matrix<float, 4, 2> const&) | tcu::Matrix<T, Rows, Cols> increment (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) + 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x654b51(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a7163
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x10, %r9
je 0x3a7158
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a7155
xorl %ecx, %ecx
movss 0x654b12(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movss (%rsi,%rdx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx)
addq $0x10, %rdx
cmpq $0x10, %rdx
je 0x3a7190
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x4, %rcx
jne 0x3a718e
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 4, 2> deqp::gles3::Functional::MatrixCaseUtils::decrement<float, 4, 2>(tcu::Matrix<float, 4, 2> const&) | tcu::Matrix<T, Rows, Cols> decrement (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) - 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x654acf(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a71e5
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x10, %r9
je 0x3a71da
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a71d7
xorl %ecx, %ecx
movss 0x65a95c(%rip), %xmm0 # 0xa01b6c
xorl %edx, %edx
movss (%rsi,%rdx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx)
addq $0x10, %rdx
cmpq $0x10, %rdx
je 0x3a7212
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x4, %rcx
jne 0x3a7210
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 2, 3> deqp::gles3::Functional::MatrixCaseUtils::negate<float, 2, 3>(tcu::Matrix<float, 2, 3> const&) | tcu::Matrix<T, Rows, Cols> negate (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = -mat(r, c);
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x654a49(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a7268
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r8,8)
incq %r8
cmpq $0x3, %r8
jne 0x3a725d
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a725a
xorl %ecx, %ecx
movaps 0x659c40(%rip), %xmm0 # 0xa00ed0
xorl %edx, %edx
movss (%rsi,%rdx,8), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a7292
leaq 0x1(%rcx), %rdx
addq $0x4, %rsi
addq $0x4, %rdi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a7290
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 2, 3> deqp::gles3::Functional::MatrixCaseUtils::increment<float, 2, 3>(tcu::Matrix<float, 2, 3> const&) | tcu::Matrix<T, Rows, Cols> increment (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) + 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x6549c8(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a72e9
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r8,8)
incq %r8
cmpq $0x3, %r8
jne 0x3a72de
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a72db
xorl %ecx, %ecx
movss 0x65498e(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movss (%rsi,%rdx,8), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a7314
leaq 0x1(%rcx), %rdx
addq $0x4, %rsi
addq $0x4, %rdi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a7312
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 2, 3> deqp::gles3::Functional::MatrixCaseUtils::decrement<float, 2, 3>(tcu::Matrix<float, 2, 3> const&) | tcu::Matrix<T, Rows, Cols> decrement (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) - 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x654945(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a736c
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r8,8)
incq %r8
cmpq $0x3, %r8
jne 0x3a7361
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a735e
xorl %ecx, %ecx
movss 0x65a7d7(%rip), %xmm0 # 0xa01b6c
xorl %edx, %edx
movss (%rsi,%rdx,8), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a7397
leaq 0x1(%rcx), %rdx
addq $0x4, %rsi
addq $0x4, %rdi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a7395
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 4, 3> deqp::gles3::Functional::MatrixCaseUtils::negate<float, 4, 3>(tcu::Matrix<float, 4, 3> const&) | tcu::Matrix<T, Rows, Cols> negate (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = -mat(r, c);
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x654729(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a758b
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a7580
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a757d
xorl %ecx, %ecx
movaps 0x65991b(%rip), %xmm0 # 0xa00ed0
xorl %edx, %edx
movss (%rsi,%rdx), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx)
addq $0x10, %rdx
cmpq $0x30, %rdx
jne 0x3a75b7
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x4, %rcx
jne 0x3a75b5
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 4, 3> deqp::gles3::Functional::MatrixCaseUtils::increment<float, 4, 3>(tcu::Matrix<float, 4, 3> const&) | tcu::Matrix<T, Rows, Cols> increment (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) + 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x6546a5(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a760f
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a7604
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a7601
xorl %ecx, %ecx
movss 0x654666(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movss (%rsi,%rdx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx)
addq $0x10, %rdx
cmpq $0x30, %rdx
jne 0x3a763c
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x4, %rcx
jne 0x3a763a
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
tcu::Matrix<float, 4, 3> deqp::gles3::Functional::MatrixCaseUtils::decrement<float, 4, 3>(tcu::Matrix<float, 4, 3> const&) | tcu::Matrix<T, Rows, Cols> decrement (const tcu::Matrix<T, Rows, Cols>& mat)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = mat(r, c) - 1.0f;
return retVal;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x65461f(%rip), %xmm0 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a7695
xorps %xmm1, %xmm1
movss %xmm1, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a768a
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a7687
xorl %ecx, %ecx
movss 0x65a4ac(%rip), %xmm0 # 0xa01b6c
xorl %edx, %edx
movss (%rsi,%rdx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx)
addq $0x10, %rdx
cmpq $0x30, %rdx
jne 0x3a76c2
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdi
cmpq $0x4, %rcx
jne 0x3a76c0
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp |
deqp::gles3::Functional::eval_negate_vec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x28(%rsp)
movss %xmm0, -0x20(%rsp)
movss %xmm1, -0x1c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movaps 0x65720e(%rip), %xmm0 # 0xa00ed0
movss -0x28(%rsp,%rax,4), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3a9cc2
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_div_ivec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %ecx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3abb62
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3abb8d
movq $0x0, -0x30(%rsp)
xorl %ecx, %ecx
movl -0x38(%rsp,%rcx,4), %eax
cltd
idivl -0x40(%rsp,%rcx,4)
movl %eax, -0x30(%rsp,%rcx,4)
incq %rcx
cmpq $0x1, %rcx
je 0x3abbab
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x30(%rsp,%rax,4), %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3abbcc
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3abc01
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_div_ivec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %ecx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3abc4f
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3abc89
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %ecx, %ecx
movl -0x60(%rsp,%rcx,4), %eax
cltd
idivl -0x70(%rsp,%rcx,4)
movl %eax, -0x50(%rsp,%rcx,4)
incq %rcx
cmpq $0x3, %rcx
jne 0x3abcaf
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x50(%rsp,%rax,4), %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3abcd8
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3abd18
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mod_ivec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %ecx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3abe41
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3abe6c
movq $0x0, -0x30(%rsp)
xorl %ecx, %ecx
movl -0x38(%rsp,%rcx,4), %eax
cltd
idivl -0x40(%rsp,%rcx,4)
movl %edx, -0x30(%rsp,%rcx,4)
incq %rcx
cmpq $0x1, %rcx
je 0x3abe8a
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x30(%rsp,%rax,4), %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3abeab
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3abee0
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mod_ivec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %ecx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ac03a
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %ecx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ac083
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %ecx, %ecx
movl -0x38(%rsp,%rcx,4), %eax
cltd
idivl -0x48(%rsp,%rcx,4)
movl %edx, -0x28(%rsp,%rcx,4)
incq %rcx
cmpq $0x4, %rcx
jne 0x3ac0a0
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x28(%rsp,%rax,4), %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ac0c0
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseAnd_ivec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %ecx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ac20b
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ac245
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %eax, %eax
movl -0x70(%rsp,%rax,4), %ecx
andl -0x60(%rsp,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ac26b
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x50(%rsp,%rax,4), %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ac293
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3ac2d3
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseOr_ivec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %ecx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac3fa
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac425
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movl -0x40(%rsp,%rax,4), %ecx
orl -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac443
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x30(%rsp,%rax,4), %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac463
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac498
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseOr_ivec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %ecx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ac4e6
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ac520
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %eax, %eax
movl -0x70(%rsp,%rax,4), %ecx
orl -0x60(%rsp,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ac546
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x50(%rsp,%rax,4), %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ac56e
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3ac5ae
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseXor_ivec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %ecx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac6d5
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac700
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movl -0x40(%rsp,%rax,4), %ecx
xorl -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac71e
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x30(%rsp,%rax,4), %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac73e
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3ac773
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseXor_ivec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %ecx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ac8cc
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %ecx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ac915
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
movl -0x48(%rsp,%rax,4), %ecx
xorl -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ac932
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x28(%rsp,%rax,4), %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ac951
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_leftShift_ivec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %ecx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3aca9e
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3acad8
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %eax, %eax
movl -0x60(%rsp,%rax,4), %edx
movb -0x70(%rsp,%rax,4), %cl
shll %cl, %edx
movl %edx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3acafe
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x50(%rsp,%rax,4), %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3acb28
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3acb68
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_rightShift_ivec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %ecx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3acca3
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3accce
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movl -0x38(%rsp,%rax,4), %edx
movb -0x40(%rsp,%rax,4), %cl
movl %edx, %esi
sarl %cl, %esi
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
shrl %cl, %r8d
notl %r8d
sarl $0x1f, %edx
andl %r8d, %edx
orl %esi, %edx
movl %edx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3accec
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x30(%rsp,%rax,4), %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3acd24
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3acd59
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_leftShiftVecScalar_ivec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x18(%rsp)
movss %xmm0, -0x14(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %ecx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3acfad
cvttss2si 0x40(%rdi), %eax
xorl %ecx, %ecx
movl %eax, -0x10(%rsp,%rcx,4)
incq %rcx
cmpq $0x1, %rcx
je 0x3acfc7
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %edx
movb -0x10(%rsp,%rax,4), %cl
shll %cl, %edx
movl %edx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3acfdf
movq $0x0, -0x20(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x28(%rsp,%rax,4), %xmm0
movss %xmm0, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ad001
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x20(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3ad036
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_rightShiftVecScalar_ivec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x38(%rsp)
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
cvttss2si -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ad3ed
cvttss2si 0x40(%rdi), %eax
xorl %ecx, %ecx
movl %eax, -0x48(%rsp,%rcx,4)
incq %rcx
cmpq $0x4, %rcx
jne 0x3ad407
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %edx
movb -0x48(%rsp,%rax,4), %cl
movl %edx, %esi
sarl %cl, %esi
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
shrl %cl, %r8d
notl %r8d
sarl $0x1f, %edx
andl %r8d, %edx
orl %esi, %edx
movl %edx, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ad41e
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x18(%rsp,%rax,4), %xmm0
movss %xmm0, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ad455
movaps -0x48(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_nop_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
movq $0x0, -0x40(%rsp)
movl $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ad84a
movl $0x0, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movl -0x40(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ad871
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x38(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3ad8b4
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseNot_uvec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x18(%rsp)
movss %xmm0, -0x14(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %rcx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3adba4
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %ecx
notl %ecx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3adbc3
movq $0x0, -0x20(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3adbe1
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x20(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3adc19
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_addOne_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
movq $0x0, -0x50(%rsp)
movl $0x0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ade97
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %ecx
incl %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3adebe
movl $0x0, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movl -0x40(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3adee4
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x38(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3adf27
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_subOne_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
movq $0x0, -0x50(%rsp)
movl $0x0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ae0db
movl $0x0, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %ecx
decl %ecx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ae102
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ae128
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3ae16b
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_add_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ae44f
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %rcx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ae499
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
movl -0x48(%rsp,%rax,4), %ecx
addl -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ae4b7
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ae4d6
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_sub_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ae73c
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %rcx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ae786
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
movl -0x38(%rsp,%rax,4), %ecx
subl -0x48(%rsp,%rax,4), %ecx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ae7a4
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3ae7c3
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mul_uvec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ae829
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %rcx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ae855
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movl -0x40(%rsp,%rax,4), %ecx
imull -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ae874
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3ae895
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3ae8cd
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mul_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aea2c
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %rcx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aea76
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
movl -0x48(%rsp,%rax,4), %ecx
imull -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aea94
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aeab4
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_div_uvec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3aeb1b
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %rcx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3aeb47
movq $0x0, -0x30(%rsp)
xorl %ecx, %ecx
movl -0x38(%rsp,%rcx,4), %eax
xorl %edx, %edx
divl -0x40(%rsp,%rcx,4)
movl %eax, -0x30(%rsp,%rcx,4)
incq %rcx
cmpq $0x1, %rcx
je 0x3aeb66
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3aeb88
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3aebc0
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_div_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %rcx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3aec0e
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3aec49
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %ecx, %ecx
movl -0x60(%rsp,%rcx,4), %eax
xorl %edx, %edx
divl -0x70(%rsp,%rcx,4)
movl %eax, -0x50(%rsp,%rcx,4)
incq %rcx
cmpq $0x3, %rcx
jne 0x3aec70
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3aec9a
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3aecdd
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_div_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aed20
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %rcx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aed6a
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %ecx, %ecx
movl -0x38(%rsp,%rcx,4), %eax
xorl %edx, %edx
divl -0x48(%rsp,%rcx,4)
movl %eax, -0x28(%rsp,%rcx,4)
incq %rcx
cmpq $0x4, %rcx
jne 0x3aed88
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aeda9
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mod_uvec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3aee10
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %rcx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3aee3c
movq $0x0, -0x30(%rsp)
xorl %ecx, %ecx
movl -0x38(%rsp,%rcx,4), %eax
xorl %edx, %edx
divl -0x40(%rsp,%rcx,4)
movl %edx, -0x30(%rsp,%rcx,4)
incq %rcx
cmpq $0x1, %rcx
je 0x3aee5b
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3aee7d
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3aeeb5
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mod_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %rcx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3aef03
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3aef3e
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %ecx, %ecx
movl -0x60(%rsp,%rcx,4), %eax
xorl %edx, %edx
divl -0x70(%rsp,%rcx,4)
movl %edx, -0x50(%rsp,%rcx,4)
incq %rcx
cmpq $0x3, %rcx
jne 0x3aef65
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3aef8f
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3aefd2
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mod_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af015
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %rcx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af05f
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %ecx, %ecx
movl -0x38(%rsp,%rcx,4), %eax
xorl %edx, %edx
divl -0x48(%rsp,%rcx,4)
movl %edx, -0x28(%rsp,%rcx,4)
incq %rcx
cmpq $0x4, %rcx
jne 0x3af07d
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af09e
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseAnd_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %rcx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af1f4
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af22f
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %eax, %eax
movl -0x70(%rsp,%rax,4), %ecx
andl -0x60(%rsp,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af256
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af27e
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3af2c1
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseAnd_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af304
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %rcx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af34e
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
movl -0x48(%rsp,%rax,4), %ecx
andl -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af36c
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af38b
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseOr_uvec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3af3f0
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %rcx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3af41c
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movl -0x40(%rsp,%rax,4), %ecx
orl -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3af43b
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3af45b
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3af493
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseOr_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %rcx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af4e1
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af51c
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %eax, %eax
movl -0x70(%rsp,%rax,4), %ecx
orl -0x60(%rsp,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af543
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af56b
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3af5ae
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseOr_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af5f1
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %rcx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af63b
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
movl -0x48(%rsp,%rax,4), %ecx
orl -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af659
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3af678
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseXor_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %rcx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af7ce
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af809
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %eax, %eax
movl -0x70(%rsp,%rax,4), %ecx
xorl -0x60(%rsp,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af830
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3af858
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3af89b
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_leftShift_uvec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3af9c9
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3af9f5
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movl -0x38(%rsp,%rax,4), %edx
movb -0x40(%rsp,%rax,4), %cl
shll %cl, %edx
movl %edx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3afa13
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3afa35
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3afa6d
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_leftShift_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3afbcc
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %ecx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3afc16
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
movl -0x38(%rsp,%rax,4), %edx
movb -0x48(%rsp,%rax,4), %cl
shll %cl, %edx
movl %edx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3afc33
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3afc54
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_rightShift_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %rcx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3afdaa
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3afde5
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %eax, %eax
movl -0x60(%rsp,%rax,4), %edx
movb -0x70(%rsp,%rax,4), %cl
shrl %cl, %edx
movl %edx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3afe0b
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3afe35
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3afe78
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_rightShift_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movss %xmm1, -0x4c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x58(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3afebb
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x68(%rsp)
movss %xmm1, -0x64(%rsp)
movss %xmm3, -0x60(%rsp)
movss %xmm2, -0x5c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x68(%rsp,%rax,4), %ecx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aff05
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
movl -0x38(%rsp,%rax,4), %edx
movb -0x48(%rsp,%rax,4), %cl
shrl %cl, %edx
movl %edx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aff22
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3aff43
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_leftShiftVecScalar_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
movq $0x0, -0x50(%rsp)
movl $0x0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b0067
cvttss2si 0x40(%rdi), %eax
xorl %ecx, %ecx
movl %eax, -0x18(%rsp,%rcx,4)
incq %rcx
cmpq $0x3, %rcx
jne 0x3b0082
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %edx
movb -0x18(%rsp,%rax,4), %cl
shll %cl, %edx
movl %edx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b00a2
movq $0x0, -0x30(%rsp)
movl $0x0, -0x28(%rsp)
xorl %eax, %eax
movl -0x40(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b00cc
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x38(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3b010f
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_rightShiftVecScalar_uvec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x18(%rsp)
movss %xmm0, -0x14(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %rcx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b01ee
cvttss2si 0x40(%rdi), %eax
xorl %ecx, %ecx
movl %eax, -0x10(%rsp,%rcx,4)
incq %rcx
cmpq $0x1, %rcx
je 0x3b0209
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %edx
movb -0x10(%rsp,%rax,4), %cl
shrl %cl, %edx
movl %edx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b0221
movq $0x0, -0x20(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b0243
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x20(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3b027b
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_rightShiftVecScalar_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x38(%rsp)
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
cvttss2si -0x38(%rsp,%rax,4), %rcx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3b03b4
cvttss2si 0x40(%rdi), %eax
xorl %ecx, %ecx
movl %eax, -0x48(%rsp,%rcx,4)
incq %rcx
cmpq $0x4, %rcx
jne 0x3b03cf
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %edx
movb -0x48(%rsp,%rax,4), %cl
shrl %cl, %edx
movl %edx, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3b03e6
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rsp)
xorl %eax, %eax
movl -0x18(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3b0407
movaps -0x48(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_selection_uvec3(deqp::gls::ShaderEvalContext&) | void eval_selection_uvec3 (ShaderEvalContext& c) { c.color.xyz() = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(1, 2, 0).asUint(), c.in[2].swizzle(3, 1, 2).asUint()).asFloat(); } | movss 0x38(%rdi), %xmm0
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm1
movq %rax, -0x24(%rsp)
movss %xmm1, -0x1c(%rsp)
movq $0x0, -0x58(%rsp)
movl $0x0, -0x50(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x58(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b0560
movss 0x5c(%rdi), %xmm1
movss 0x54(%rdi), %xmm2
movss 0x58(%rdi), %xmm3
movss %xmm1, -0x3c(%rsp)
movss %xmm2, -0x38(%rsp)
movss %xmm3, -0x34(%rsp)
movq $0x0, -0x68(%rsp)
movl $0x0, -0x60(%rsp)
xorl %eax, %eax
cvttss2si -0x3c(%rsp,%rax,4), %rcx
movl %ecx, -0x68(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b05a8
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
leaq -0x58(%rsp), %rax
leaq -0x68(%rsp), %rcx
cmovaq %rax, %rcx
movl 0x8(%rcx), %eax
movl %eax, -0x28(%rsp)
movq (%rcx), %rax
movq %rax, -0x30(%rsp)
movq $0x0, -0x48(%rsp)
movl $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x30(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b05f2
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x50(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3b0635
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderOperatorTests.cpp |
deqp::gles3::Functional::eval_boolNot_bvec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x18(%rsp)
movw $0x0, -0x2c(%rsp)
xorl %eax, %eax
movss -0x20(%rsp,%rax,4), %xmm0
ucomiss -0x18(%rsp,%rax,4), %xmm0
seta -0x2c(%rsp,%rax)
incq %rax
cmpq $0x1, %rax
je 0x3b077b
movw $0x0, -0x2a(%rsp)
xorl %eax, %eax
movb -0x2c(%rsp,%rax), %cl
xorb $0x1, %cl
movb %cl, -0x2a(%rsp,%rax)
incq %rax
cmpq $0x1, %rax
je 0x3b079d
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movsbl -0x2a(%rsp,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b07bc
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3b07f4
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_boolNot_bvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x38(%rsp)
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
movl $0x0, -0x40(%rsp)
xorl %eax, %eax
movss -0x38(%rsp,%rax,4), %xmm0
ucomiss -0x18(%rsp,%rax,4), %xmm0
seta -0x40(%rsp,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x3b092a
movl $0x0, -0x3c(%rsp)
xorl %eax, %eax
movb -0x40(%rsp,%rax), %cl
xorb $0x1, %cl
movb %cl, -0x3c(%rsp,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x3b094d
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
movsbl -0x3c(%rsp,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3b096b
movaps -0x28(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_selection_bvec3(deqp::gls::ShaderEvalContext&) | void eval_selection_bvec3 (ShaderEvalContext& c) { c.color.xyz() = selection(c.in[0].z() > 0.0f, greaterThan(c.in[1].swizzle(1, 2, 0), Vec3(0.0f, 0.0f, 0.0f)), greaterThan(c.in[2].swizzle(3, 1, 2), Vec3(0.0f, 0.0f, 0.0f))).asFloat(); } | movss 0x38(%rdi), %xmm0
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm1
movq %rax, -0x24(%rsp)
movss %xmm1, -0x1c(%rsp)
movq $0x0, -0x30(%rsp)
movl $0x0, -0x28(%rsp)
movw $0x0, -0x60(%rsp)
movb $0x0, -0x5e(%rsp)
xorl %eax, %eax
movss -0x24(%rsp,%rax,4), %xmm1
ucomiss -0x30(%rsp,%rax,4), %xmm1
seta -0x60(%rsp,%rax)
incq %rax
cmpq $0x3, %rax
jne 0x3b0b8a
movss 0x5c(%rdi), %xmm1
movss 0x54(%rdi), %xmm2
movss 0x58(%rdi), %xmm3
movss %xmm1, -0x48(%rsp)
movss %xmm2, -0x44(%rsp)
movss %xmm3, -0x40(%rsp)
movq $0x0, -0x3c(%rsp)
movl $0x0, -0x34(%rsp)
movw $0x0, -0x64(%rsp)
movb $0x0, -0x62(%rsp)
xorl %eax, %eax
movss -0x48(%rsp,%rax,4), %xmm1
ucomiss -0x3c(%rsp,%rax,4), %xmm1
seta -0x64(%rsp,%rax)
incq %rax
cmpq $0x3, %rax
jne 0x3b0be3
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
leaq -0x60(%rsp), %rax
leaq -0x64(%rsp), %rcx
cmovaq %rax, %rcx
movb 0x2(%rcx), %al
movb %al, -0x5a(%rsp)
movzwl (%rcx), %eax
movw %ax, -0x5c(%rsp)
movq $0x0, -0x58(%rsp)
movl $0x0, -0x50(%rsp)
xorl %eax, %eax
movsbl -0x5c(%rsp,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, -0x58(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b0c32
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x60(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3b0c75
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderOperatorTests.cpp |
deqp::gles3::Functional::eval_addVecScalar_vec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x18(%rsp)
movss %xmm0, -0x14(%rsp)
movss 0x40(%rdi), %xmm0
movq $0x0, -0x20(%rsp)
xorl %eax, %eax
movss -0x18(%rsp,%rax,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b0db4
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x20(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3b0dea
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_addVecScalar_vec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x28(%rsp)
movss %xmm0, -0x20(%rsp)
movss %xmm1, -0x1c(%rsp)
movss 0x40(%rdi), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x18(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3b0ec6
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_subVecScalar_vec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
movss 0x40(%rdi), %xmm0
movl $0x0, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movss -0x24(%rsp,%rax,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b0f9b
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x38(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3b0fdc
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mulVecScalar_vec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
movss 0x40(%rdi), %xmm0
movl $0x0, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movss -0x24(%rsp,%rax,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b10f9
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x38(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3b113a
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_divVecScalar_vec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x18(%rsp)
movss %xmm0, -0x14(%rsp)
movss 0x40(%rdi), %xmm0
movq $0x0, -0x20(%rsp)
xorl %eax, %eax
movss -0x18(%rsp,%rax,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b11ce
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x20(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3b1204
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_divVecScalar_vec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x28(%rsp)
movss %xmm0, -0x20(%rsp)
movss %xmm1, -0x1c(%rsp)
movss 0x40(%rdi), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x18(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3b12e0
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_subScalarVec_vec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movq 0x40(%rdi), %rax
rolq $0x20, %rax
movss 0x38(%rdi), %xmm0
movq %rax, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
xorl %eax, %eax
movaps %xmm0, %xmm1
subss -0x18(%rsp,%rax,4), %xmm1
movss %xmm1, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b1478
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x20(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3b14ad
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_divScalarVec_vec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movq 0x40(%rdi), %rax
rolq $0x20, %rax
movss 0x38(%rdi), %xmm0
movq %rax, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
xorl %eax, %eax
movaps %xmm0, %xmm1
divss -0x18(%rsp,%rax,4), %xmm1
movss %xmm1, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b171f
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x20(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3b1754
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_addVecScalar_ivec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
movq $0x0, -0x50(%rsp)
movl $0x0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b1939
cvttss2si 0x40(%rdi), %eax
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %ecx, %ecx
movl -0x50(%rsp,%rcx,4), %edx
addl %eax, %edx
movl %edx, -0x40(%rsp,%rcx,4)
incq %rcx
cmpq $0x3, %rcx
jne 0x3b1964
movl $0x0, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x40(%rsp,%rax,4), %xmm0
movss %xmm0, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b198a
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x38(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3b19ca
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_subVecScalar_ivec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x18(%rsp)
movss %xmm0, -0x14(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
cvttss2si -0x18(%rsp,%rax,4), %ecx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b1a92
cvttss2si 0x40(%rdi), %eax
movq $0x0, -0x28(%rsp)
xorl %ecx, %ecx
movl -0x30(%rsp,%rcx,4), %edx
subl %eax, %edx
movl %edx, -0x28(%rsp,%rcx,4)
incq %rcx
cmpq $0x1, %rcx
je 0x3b1ab5
movq $0x0, -0x20(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x28(%rsp,%rax,4), %xmm0
movss %xmm0, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3b1ad3
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x20(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3b1b08
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mulVecScalar_ivec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
movq $0x0, -0x50(%rsp)
movl $0x0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b1d74
cvttss2si 0x40(%rdi), %eax
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %ecx, %ecx
movl -0x50(%rsp,%rcx,4), %edx
imull %eax, %edx
movl %edx, -0x40(%rsp,%rcx,4)
incq %rcx
cmpq $0x3, %rcx
jne 0x3b1d9f
movl $0x0, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x40(%rsp,%rax,4), %xmm0
movss %xmm0, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b1dc6
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x38(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3b1e06
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_bitwiseXorVecScalar_ivec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
movq $0x0, -0x50(%rsp)
movl $0x0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b28b7
cvttss2si 0x40(%rdi), %eax
xorl %ecx, %ecx
movl %eax, -0x18(%rsp,%rcx,4)
incq %rcx
cmpq $0x3, %rcx
jne 0x3b28d1
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x18(%rsp,%rax,4), %ecx
xorl -0x50(%rsp,%rax,4), %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b28f1
movq $0x0, -0x30(%rsp)
movl $0x0, -0x28(%rsp)
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl -0x40(%rsp,%rax,4), %xmm0
movss %xmm0, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3b2919
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x38(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3b2959
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_max_uvec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %rcx
movl %ecx, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3bb1af
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq $0x0, -0x70(%rsp)
movl $0x0, -0x68(%rsp)
xorl %eax, %eax
cvttss2si -0x24(%rsp,%rax,4), %rcx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3bb1ea
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %eax, %eax
movl -0x60(%rsp,%rax,4), %ecx
movl -0x70(%rsp,%rax,4), %edx
cmpl %edx, %ecx
cmoval %ecx, %edx
movl %edx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3bb211
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movl -0x50(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3bb23e
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3bb281
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_clampVecScalarScalar_uvec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x48(%rsp)
movss %xmm0, -0x40(%rsp)
movss %xmm1, -0x3c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x38(%rsp)
xorl %eax, %eax
cvttss2si -0x48(%rsp,%rax,4), %rcx
movl %ecx, -0x38(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3bc5c4
cvttss2si 0x40(%rdi), %rax
cvttss2si 0x54(%rdi), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %edx, %edx
movl -0x38(%rsp,%rdx,4), %esi
cmpl %ecx, %esi
movl %ecx, %r8d
cmovbl %esi, %r8d
cmpl %eax, %esi
cmovbl %eax, %r8d
movl %r8d, -0x28(%rsp,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3bc5ee
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movl -0x28(%rsp,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3bc619
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mix_vec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x28(%rsp)
movss %xmm0, -0x20(%rsp)
movss %xmm1, -0x1c(%rsp)
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x38(%rsp)
movss %xmm1, -0x34(%rsp)
movss %xmm3, -0x30(%rsp)
movss %xmm2, -0x2c(%rsp)
movss 0x5c(%rdi), %xmm0
movss 0x58(%rdi), %xmm1
movss 0x50(%rdi), %xmm2
movss 0x54(%rdi), %xmm3
movss %xmm2, -0x48(%rsp)
movss %xmm0, -0x44(%rsp)
movss %xmm1, -0x40(%rsp)
movss %xmm3, -0x3c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movss 0x63f429(%rip), %xmm0 # 0x9fbca0
movss -0x48(%rsp,%rax,4), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
mulss -0x38(%rsp,%rax,4), %xmm1
mulss -0x28(%rsp,%rax,4), %xmm2
addss %xmm1, %xmm2
movss %xmm2, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3bc877
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_mixVecVecScalar_vec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movss 0x54(%rdi), %xmm0
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
movss 0x63f300(%rip), %xmm1 # 0x9fbca0
subss %xmm0, %xmm1
xorl %eax, %eax
movss -0x24(%rsp,%rax,4), %xmm2
mulss %xmm0, %xmm2
movss -0x30(%rsp,%rax,4), %xmm3
mulss %xmm1, %xmm3
addss %xmm2, %xmm3
movss %xmm3, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3bc9a6
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3bc9f5
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_step_vec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x20(%rsp)
movss %xmm0, -0x1c(%rsp)
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x28(%rsp)
xorl %eax, %eax
movss 0x63f1a2(%rip), %xmm0 # 0x9fbca0
movss -0x18(%rsp,%rax,4), %xmm1
cmpltss -0x20(%rsp,%rax,4), %xmm1
andnps %xmm0, %xmm1
movss %xmm1, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3bcafe
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3bcb3a
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_step_vec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x28(%rsp)
movss %xmm0, -0x20(%rsp)
movss %xmm1, -0x1c(%rsp)
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x38(%rsp)
movss %xmm1, -0x34(%rsp)
movss %xmm3, -0x30(%rsp)
movss %xmm2, -0x2c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movss 0x63f03e(%rip), %xmm0 # 0x9fbca0
movss -0x38(%rsp,%rax,4), %xmm1
cmpltss -0x28(%rsp,%rax,4), %xmm1
andnps %xmm0, %xmm1
movss %xmm1, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3bcc62
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_smoothStep_vec2(deqp::gls::ShaderEvalContext&) | Vector<T, 2> swizzle (int a, int b) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); return Vector<T, 2>(m_data[a], m_data[b]); } | movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, -0x28(%rsp)
movss %xmm0, -0x24(%rsp)
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq 0x54(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x20(%rsp)
movq $0x0, -0x30(%rsp)
xorl %eax, %eax
movss 0x63ee00(%rip), %xmm0 # 0x9fbca0
movss 0x64f440(%rip), %xmm1 # 0xa0c2e8
movss -0x28(%rsp,%rax,4), %xmm3
movss -0x20(%rsp,%rax,4), %xmm2
xorps %xmm4, %xmm4
ucomiss %xmm2, %xmm3
jae 0x3bceec
movss -0x18(%rsp,%rax,4), %xmm5
ucomiss %xmm5, %xmm2
movaps %xmm0, %xmm4
jae 0x3bceec
subss %xmm3, %xmm2
subss %xmm3, %xmm5
divss %xmm5, %xmm2
movaps %xmm2, %xmm3
mulss %xmm2, %xmm3
addss %xmm2, %xmm2
movaps %xmm1, %xmm4
subss %xmm2, %xmm4
mulss %xmm3, %xmm4
movss %xmm4, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3bcea8
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x10(%rsp)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rsp)
xorl %eax, %eax
movss -0x30(%rsp,%rax,4), %xmm0
movslq -0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x1, %rax
je 0x3bcf18
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_smoothStep_vec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movss 0x5c(%rdi), %xmm0
movss 0x54(%rdi), %xmm1
movss 0x58(%rdi), %xmm2
movss %xmm0, -0x3c(%rsp)
movss %xmm1, -0x38(%rsp)
movss %xmm2, -0x34(%rsp)
movq $0x0, -0x48(%rsp)
movl $0x0, -0x40(%rsp)
xorl %eax, %eax
movss 0x63ecfd(%rip), %xmm0 # 0x9fbca0
movss 0x64f33d(%rip), %xmm1 # 0xa0c2e8
movss -0x30(%rsp,%rax,4), %xmm3
movss -0x3c(%rsp,%rax,4), %xmm2
xorps %xmm4, %xmm4
ucomiss %xmm2, %xmm3
jae 0x3bcfef
movss -0x24(%rsp,%rax,4), %xmm5
ucomiss %xmm5, %xmm2
movaps %xmm0, %xmm4
jae 0x3bcfef
subss %xmm3, %xmm2
subss %xmm3, %xmm5
divss %xmm5, %xmm2
movaps %xmm2, %xmm3
mulss %xmm2, %xmm3
addss %xmm2, %xmm2
movaps %xmm1, %xmm4
subss %xmm2, %xmm4
mulss %xmm3, %xmm4
movss %xmm4, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3bcfab
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x50(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3bd026
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_length_vec2(deqp::gls::ShaderEvalContext&) | void eval_cross_vec3 (ShaderEvalContext& c) { c.color.xyz() = cross(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0)); } | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movss 0x34(%rdi), %xmm0
movss 0x3c(%rdi), %xmm1
movss %xmm1, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
xorps %xmm0, %xmm0
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rax
cmpq $0x1, %rax
je 0x3bd3f5
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x3bd41a
sqrtss %xmm0, %xmm0
jmp 0x3bd41f
callq 0x325ea0
movss %xmm0, 0x1f0(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderOperatorTests.cpp |
deqp::gles3::Functional::eval_faceForward_vec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x3c(%rsp)
movss %xmm1, -0x38(%rsp)
movss %xmm2, -0x34(%rsp)
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movss 0x5c(%rdi), %xmm0
movss 0x54(%rdi), %xmm1
movss 0x58(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
xorps %xmm0, %xmm0
xorl %eax, %eax
movss -0x30(%rsp,%rax,4), %xmm1
mulss -0x24(%rsp,%rax,4), %xmm1
addss %xmm1, %xmm0
incq %rax
cmpq $0x3, %rax
jne 0x3bdcaa
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3bdcdf
movl -0x34(%rsp), %eax
movl %eax, -0x40(%rsp)
movq -0x3c(%rsp), %rax
movq %rax, -0x48(%rsp)
jmp 0x3bdd11
movl $0x0, -0x40(%rsp)
movq $0x0, -0x48(%rsp)
xorl %eax, %eax
movaps 0x6431d7(%rip), %xmm0 # 0xa00ed0
movss -0x3c(%rsp,%rax,4), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, -0x48(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3bdcf9
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x50(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3bdd39
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_refract_vec3(deqp::gls::ShaderEvalContext&) | void eval_refract_vec3 (ShaderEvalContext& c) { c.color.xyz() = refract(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0), c.in[2].y()); } | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, 0x14(%rsp)
movss %xmm1, 0x18(%rsp)
movss %xmm2, 0x1c(%rsp)
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, 0x44(%rsp)
movss %xmm0, 0x4c(%rsp)
movss 0x54(%rdi), %xmm3
xorps %xmm4, %xmm4
xorl %eax, %eax
movss 0x44(%rsp,%rax,4), %xmm0
mulss 0x14(%rsp,%rax,4), %xmm0
addss %xmm0, %xmm4
incq %rax
cmpq $0x3, %rax
jne 0x3be335
movaps %xmm4, %xmm1
mulss %xmm4, %xmm1
movss 0x63d943(%rip), %xmm0 # 0x9fbca0
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
movaps %xmm3, %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3be390
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
jmp 0x3be447
movl $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
xorl %eax, %eax
movss 0x14(%rsp,%rax,4), %xmm1
mulss %xmm3, %xmm1
movss %xmm1, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3be3a3
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x3be3ca
sqrtss %xmm0, %xmm0
jmp 0x3be3e7
movss %xmm3, 0x10(%rsp)
movss %xmm4, 0xc(%rsp)
callq 0x325ea0
movss 0xc(%rsp), %xmm4
movss 0x10(%rsp), %xmm3
mulss %xmm4, %xmm3
addss %xmm0, %xmm3
movl $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
xorl %eax, %eax
movss 0x44(%rsp,%rax,4), %xmm0
mulss %xmm3, %xmm0
movss %xmm0, 0x38(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3be402
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
xorl %eax, %eax
movss 0x20(%rsp,%rax,4), %xmm0
subss 0x38(%rsp,%rax,4), %xmm0
movss %xmm0, (%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3be42d
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x20(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x28(%rsp)
movl $0x2, 0x30(%rsp)
movl $0x2, %eax
movss -0x8(%rsp,%rax,4), %xmm0
movslq 0x20(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3be46f
addq $0x50, %rsp
popq %rbx
retq
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderOperatorTests.cpp |
deqp::gles3::Functional::eval_greaterThanEqual_vec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movw $0x0, -0x44(%rsp)
movb $0x0, -0x42(%rsp)
xorl %eax, %eax
movss -0x30(%rsp,%rax,4), %xmm0
ucomiss -0x24(%rsp,%rax,4), %xmm0
setae -0x44(%rsp,%rax)
incq %rax
cmpq $0x3, %rax
jne 0x3bf065
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movsbl -0x44(%rsp,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3bf091
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3bf0d4
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_notEqual_vec3(deqp::gls::ShaderEvalContext&) | Vector<T, 3> swizzle (int a, int b, int c) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); return Vector<T, 3>(m_data[a], m_data[b], m_data[c]); } | movss 0x38(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movss 0x34(%rdi), %xmm2
movss %xmm0, -0x30(%rsp)
movss %xmm1, -0x2c(%rsp)
movss %xmm2, -0x28(%rsp)
movq 0x44(%rdi), %rax
movss 0x40(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movw $0x0, -0x44(%rsp)
movb $0x0, -0x42(%rsp)
xorl %eax, %eax
movss -0x30(%rsp,%rax,4), %xmm0
ucomiss -0x24(%rsp,%rax,4), %xmm0
setp %cl
setne %dl
orb %cl, %dl
movb %dl, -0x44(%rsp,%rax)
incq %rax
cmpq $0x3, %rax
jne 0x3bf4db
movl $0x0, -0x38(%rsp)
movq $0x0, -0x40(%rsp)
xorl %eax, %eax
movsbl -0x44(%rsp,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3bf50e
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x48(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3bf551
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_notEqual_vec4(deqp::gls::ShaderEvalContext&) | Vector<T, 4> swizzle (int a, int b, int c, int d) const { DE_ASSERT(a >= 0 && a < Size); DE_ASSERT(b >= 0 && b < Size); DE_ASSERT(c >= 0 && c < Size); DE_ASSERT(d >= 0 && d < Size); return Vector<T, 4>(m_data[a], m_data[b], m_data[c], m_data[d]); } | movq 0x34(%rdi), %rax
movss 0x3c(%rdi), %xmm0
movss 0x30(%rdi), %xmm1
movq %rax, -0x28(%rsp)
movss %xmm0, -0x20(%rsp)
movss %xmm1, -0x1c(%rsp)
movss 0x4c(%rdi), %xmm0
movss 0x48(%rdi), %xmm1
movss 0x40(%rdi), %xmm2
movss 0x44(%rdi), %xmm3
movss %xmm0, -0x38(%rsp)
movss %xmm1, -0x34(%rsp)
movss %xmm3, -0x30(%rsp)
movss %xmm2, -0x2c(%rsp)
movl $0x0, -0x3c(%rsp)
xorl %eax, %eax
movss -0x28(%rsp,%rax,4), %xmm0
ucomiss -0x38(%rsp,%rax,4), %xmm0
setp %cl
setne %dl
orb %cl, %dl
movb %dl, -0x3c(%rsp,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x3bf5c0
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movsbl -0x3c(%rsp,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3bf5ea
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x1f0(%rdi)
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.