name string | code string | asm string | file string |
|---|---|---|---|
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
c... | /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 +=... | 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 0x3... | /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 +=... | 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 ... | /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, (%r... | /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, (%r... | /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, (%r... | /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, (%r... | /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 +=... | 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 $0... | /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 +=... | 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... | /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 ... | /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 0x... | /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
... | /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... | /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, %... | /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,... | /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,... | /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,... | /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 ... | /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 ... | /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 ... | /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
... | /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
... | /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
... | /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... | /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... | /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... | /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
cmp... | /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
cmp... | /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
cmp... | /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... | /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(%... | /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 0x... | /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(%... | /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(%... | /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 0x... | /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(%... | /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 0x... | /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(%... | /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(%... | /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 0x... | /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(%... | /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 %r... | /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 0x... | /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 $0... | /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
m... | /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 $0... | /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 $0... | /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(%... | /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(%... | /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(%... | /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(%... | /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(%... | /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 0x... | /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(%... | /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(%... | /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 0x... | /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(%... | /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 0x... | /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(%... | /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(%... | /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 0x... | /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(%... | /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 0x... | /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(%... | /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(%... | /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 0x... | /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(%... | /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
cvttss2... | /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 %r... | /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 0x... | /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(%... | /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, ... | /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 ... | /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 %... | /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 = 0... | /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... | /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... | /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... | /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 = 0... | /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... | /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... | /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... | /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
cvttss2... | /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(%rs... | /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
cvttss2... | /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
cvttss2... | /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 0x... | /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 0x... | /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 ... | /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 0x6... | /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, ... | /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 ... | /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(%ri... | /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 %... | /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
j... | /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 %... | /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, %xm... | /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,... | /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,... | /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 ... | /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.