name string | code string | asm string | file string |
|---|---|---|---|
deqp::gles3::Functional::eval_allEqual_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, -0x10(%rsp)
movss %xmm0, -0xc(%rsp)
movq $0x0, -0x18(%rsp)
xorl %eax, %eax
cvttss2si -0x10(%rsp,%rax,4), %ecx
movl %ecx, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3bf657
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x8(%rsp)
movq $0x0, -0x20(%rs... | /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_anyNotEqual_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, -0x18(%rsp)
xorl %eax, %eax
cvttss2si -0x38(%rsp,%rax,4), %ecx
movl %ecx, -0x18(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3bf9c8
movss 0x4c(%... | /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_lessThan_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, -0x30(%rsp)
xorl %eax, %eax
cvttss2si -0x20(%rsp,%rax,4), %ecx
movl %ecx, -0x30(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x3bfa9b
movq 0x40(%rdi), %rax
rolq $0x20, %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x38(%... | /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_lessThan_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, -0x48(%rsp)
movss %xmm0, -0x40(%rsp)
movss %xmm1, -0x3c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
xorl %eax, %eax
cvttss2si -0x48(%rsp,%rax,4), %ecx
movl %ecx, -0x28(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x3bfc93
movss 0x4c(%... | /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::eval_lessThan_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, -0x50(%rsp)
movl $0x0, -0x48(%rsp)
xorl %eax, %eax
cvttss2si -0x30(%rsp,%rax,4), %rcx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3c1163
movq 0x... | /kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp |
deqp::gles3::Functional::evalTexture2DProjOffsetBias(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::(anonymous namespace)::TexLookupParams const&) | static void evalTexture2DProjOffsetBias (gls::ShaderEvalContext& c, const TexLookupParams& p) { c.color = texture2DOffset(c, c.in[0].x()/c.in[0].w(), c.in[0].y()/c.in[0].w(), p.lod+c.in[1].x(), p.offset.swizzle(0,1))*p.scale + p.bias; } | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movss 0x3c(%rdi), %xmm2
movss 0x30(%rdi), %xmm0
movss 0x34(%rdi), %xmm1
divss %xmm2, %xmm0
divss %xmm2, %xmm1
movss (%rsi), %xmm2
addss 0x40(%rdi), %xmm2
movq 0x4(%rsi), %rax
leaq 0x70(%rdi), %rcx
movq 0xb0(%rdi), %rdx
movq 0x48(%rdx), %rsi
movl 0x4... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderTextureFunctionTests.cpp |
deqp::gles3::Functional::UniformCase::generateFragmentSource[abi:cxx11](std::vector<deqp::gles3::Functional::UniformCase::BasicUniform, std::allocator<deqp::gles3::Functional::UniformCase::BasicUniform>> const&) const | string UniformCase::generateFragmentSource (const vector<BasicUniform>& basicUniforms) const
{
const bool isFragmentCase = m_caseShaderType == CASESHADERTYPE_FRAGMENT || m_caseShaderType == CASESHADERTYPE_BOTH;
std::ostringstream result;
result << "#version 300 es\n"
"in mediump float v_vtxOut;\n"
"\n";... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0xa0(%rsi), %ebp
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x325e00
leaq 0x538fc4(%rip), %rsi # 0xa33be6
movl $0x2c, %edx
movq %r12, %rdi
callq 0x325e70
decl %ebp
cm... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fUniformApiTests.cpp |
deqp::gles3::Functional::UniformCase::getActiveUniforms(std::vector<deqp::gles3::Functional::UniformCase::BasicUniformReportGL, std::allocator<deqp::gles3::Functional::UniformCase::BasicUniformReportGL>>&, std::vector<deqp::gles3::Functional::UniformCase::BasicUniformReportRef, std::allocator<deqp::gles3::Functional::U... | bool UniformCase::getActiveUniforms (vector<BasicUniformReportGL>& basicUniformReportsDst, const vector<BasicUniformReportRef>& basicUniformReportsRef, const deUint32 programGL)
{
TestLog& log = m_testCtx.getLog();
GLint numActiveUniforms = 0;
GLint uniformMaxNameLength = 0;
vector<char> nameBuffer;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp # imm = 0x458
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, 0x28(%rsp)
movq %rdi, %r13
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r12
xorl %eax, %eax
leaq 0x34(%rsp), %rcx
movl %eax, (%rcx)
movl %eax, 0x24(%rsp)
xorps %xmm0, %xmm0
m... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fUniformApiTests.cpp |
deqp::gles3::Functional::BooleanStateQueryVerifiers::GetBooleanVerifier::verifyBoolean(tcu::TestContext&, unsigned int, bool) | void GetBooleanVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLboolean> state;
glGetBooleanv(name, &state);
if (!state.verifyValidity(testCtx))
return;
const GLboolean expectedGLState = reference ? GL_TRUE : GL_FALSE;
if (st... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %ecx, %ebp
movq %rsi, %rbx
leaq 0xe(%rsp), %rax
movw $0xdede, -0x1(%rax) # imm = 0xDEDE
movb $-0x22, 0x1(%rax)
addq $0x8, %rdi
movl %edx, %esi
movq %rax, %rdx
callq 0x8f648a
leaq 0xd(%rsp), %rdi
movq %rbx, %rsi
callq 0x513f30
testb %al... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fBooleanStateQueryTests.cpp |
deqp::gles3::Functional::BooleanStateQueryVerifiers::GetIntegerVerifier::verifyBoolean(tcu::TestContext&, unsigned int, bool) | void GetIntegerVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLint> state;
glGetIntegerv(name, &state);
if (!state.verifyValidity(testCtx))
return;
const GLint expectedGLState = reference ? 1 : 0;
if (state != expectedGLStat... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %ecx, %ebp
movq %rsi, %rbx
movabsq $-0x2121212121212122, %rcx # imm = 0xDEDEDEDEDEDEDEDE
leaq 0x4(%rsp), %rax
movq %rcx, -0x4(%rax)
movl $0xdededede, 0x4(%rax) # imm = 0xDEDEDEDE
addq $0x8, %rdi
movl %edx, %esi
movq %rax, %rdx
callq 0x8f8... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fBooleanStateQueryTests.cpp |
deqp::gles3::Functional::BooleanStateQueryVerifiers::GetInteger64Verifier::verifyBoolean(tcu::TestContext&, unsigned int, bool) | void GetInteger64Verifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLint64> state;
glGetInteger64v(name, &state);
if (!state.verifyValidity(testCtx))
return;
const GLint64 expectedGLState = reference ? 1 : 0;
if (state != expect... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl %ecx, %ebp
movq %rsi, %rbx
movabsq $-0x2121212121212122, %rcx # imm = 0xDEDEDEDEDEDEDEDE
leaq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movaps 0x525488(%rip), %xmm0 # 0xa37610
movaps %xmm0, -0x8(%rax)
addq $0x8, %rdi
movl %edx, %es... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fBooleanStateQueryTests.cpp |
deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard<float>::verifyValidity(tcu::TestContext&) const | bool StateQueryMemoryWriteGuard<T>::verifyValidity (tcu::TestContext& testCtx) const
{
using tcu::TestLog;
if (isPreguardContaminated())
{
testCtx.getLog() << TestLog::Message << "// ERROR: Pre-guard value was modified " << TestLog::EndMessage;
if (testCtx.getTestResult() == QP_TEST_RESULT_PASS ||
testCtx.ge... | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %rbx
cmpb $-0x22, (%rdi)
jne 0x5149e0
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x3, %rcx
je 0x5149d6
leaq 0x1(%rax), %rcx
cmpb $-0x22, 0x1(%rdi,%rax)
je 0x5149c2
cmpq $0x2, %rax
ja 0x514a63
movq 0x10(%rbx), %rax
leaq 0x10(%rsp), %r14
movq %rax, -0... | /kaydenl[P]VK-GL-CTS/modules/gles3/../glshared/glsStateQueryUtil.hpp |
deqp::gles3::Functional::Integer64StateQueryVerifiers::GetFloatVerifier::verifyUnsignedInteger64GreaterOrEqual(tcu::TestContext&, unsigned int, unsigned long) | void GetFloatVerifier::verifyUnsignedInteger64GreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint64 reference)
{
using tcu::TestLog;
StateQueryMemoryWriteGuard<GLfloat> state;
glGetFloatv(name, &state);
if (!state.verifyValidity(testCtx))
return;
if (state < GLfloat(reference))
{
testCtx.getLog(... | pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rcx, %r14
movq %rsi, %rbx
movabsq $-0x2121212121212122, %rcx # imm = 0xDEDEDEDEDEDEDEDE
leaq 0xc(%rsp), %rax
movq %rcx, -0x4(%rax)
movl $0xdededede, 0x4(%rax) # imm = 0xDEDEDEDE
addq $0x8, %rdi
movl %edx, %esi
movq %rax, %rdx
callq 0x8f7b80
leaq 0x... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fInteger64StateQueryTests.cpp |
deqp::gles3::Functional::Integer64StateQueryTests::init() | void Integer64StateQueryTests::init (void)
{
DE_ASSERT(m_verifierBoolean == DE_NULL);
DE_ASSERT(m_verifierInteger == DE_NULL);
DE_ASSERT(m_verifierFloat == DE_NULL);
m_verifierBoolean = new GetBooleanVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
m_verifierInteger ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r13
movl $0x28, %edi
callq 0x325210
movq %rax, %r14
movq 0x70(%r13), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x70(%r13), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rdx
movq %r14, %rdi
addq $0x8, %rdi
... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fInteger64StateQueryTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::LineRenderTestCase::testRender() | void LineRenderTestCase::testRender (void)
{
using tcu::TestLog;
const int numSamples = de::max(m_context.getRenderTarget().getNumSamples(), 1);
const int verticesPerLine = 2;
tcu::TestLog& log = m_testCtx.getLog();
sglr::GLContext glesContext (m_context.getRenderContext(), log, 0, tcu::IVec4(0, 0, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6778, %rsp # imm = 0x6778
movq %rdi, %r13
movq 0x70(%rdi), %rdi
callq 0x335b60
movl 0x20(%rax), %eax
cmpl $0x2, %eax
movl $0x1, %ebx
cmovgel %eax, %ebx
movq 0x8(%r13), %rax
movq 0x10(%rax), %r12
movq 0x70(%r13), %rax
movq 0x8(%rax), %rs... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fClippingTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::TriangleCaseBase::TriangleCaseBase(deqp::gles3::Context&, char const*, char const*, deqp::gles3::Functional::(anonymous namespace)::TriangleCaseBase::TriangleData const*, deqp::gles3::Functional::(anonymous namespace)::TriangleCaseBase::TriangleData const*, rr::WindowRect... | TriangleCaseBase::TriangleCaseBase (Context& context, const char* name, const char* description, const TriangleData* polysBegin, const TriangleData* polysEnd, const rr::WindowRectangle& viewport)
: RenderTestCase(context, name, description)
, m_polys (polysBegin, polysEnd)
, m_viewport (viewport)
{
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r14
movq %r8, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x9a9abc
movq %r12, 0x70(%rbx)
leaq 0x6eaa2e(%rip), %rax # 0xc35a28
movq %rax, (%rbx)
leaq 0x78(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
movq $0x0, 0x88(%rbx)
mo... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fClippingTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::TriangleCase::verifyImage(tcu::ConstPixelBufferAccess const&, tcu::ConstPixelBufferAccess const&) | void TriangleCase::verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess)
{
const int kernelRadius = 1;
const int faultyLimit = 6;
tcu::TestLog& log = m_testCtx.getLog();
tcu::Surface diffMask (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE);
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4b8, %rsp # imm = 0x4B8
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r14
movq %rsp, %rdi
movl $0xc8, %esi
movl $0xc8, %edx
callq 0x9a957c
leaq 0x340(%rsp), %r13
movq %r14, -0x8(%r13)
movq %r13,... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fClippingTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::QuadFillTest::QuadFillTest(deqp::gles3::Context&, char const*, char const*, rr::WindowRectangle const&, tcu::Vector<float, 3> const&, tcu::Vector<float, 3> const&, tcu::Vector<float, 3> const&) | QuadFillTest::QuadFillTest (Context& context, const char* name, const char* description, const rr::WindowRectangle& viewport, const tcu::Vec3& d1, const tcu::Vec3& d2, const tcu::Vec3& center_)
: TriangleFillTest(context, name, description, viewport)
{
const float radius = 40000.0f;
const tcu::Vec4 center = tcu::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %r9, %r12
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x4f2cbd(%rip), %rcx # 0xa40dc4
callq 0x9a9abc
movq %r14, 0x70(%rbx)
movups 0x4f1d69(%rip), %xmm0 # 0xa3fe80
movups ... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fClippingTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::FillTest::testRender() | void FillTest::testRender (void)
{
using tcu::TestLog;
const int numSamples = 1;
tcu::TestLog& log = m_testCtx.getLog();
sglr::GLContext glesContext (m_context.getRenderContext(), log, 0, tcu::IVec4(0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE));
sglr::ReferenceContextLimits limits;
sglr::ReferenceCo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6958, %rsp # imm = 0x6958
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r14
movq 0x70(%rdi), %rax
movq 0x8(%rax), %rsi
movaps 0x4f0ecd(%rip), %xmm0 # 0xa3f5a0
leaq 0x7a8(%rsp), %r8
movups %xmm0, (%r8)
leaq 0x638(%rsp), %rdi
x... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fClippingTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::PolyVertexClipTestGroup::init() | void PolyVertexClipTestGroup::init (void)
{
const float far = 30000.0f;
const tcu::IVec3 outside[] =
{
// outside one clipping plane
tcu::IVec3(-1, 0, 0),
tcu::IVec3( 1, 0, 0),
tcu::IVec3( 0, 1, 0),
tcu::IVec3( 0, -1, 0),
tcu::IVec3( 0, 0, 1),
tcu::IVec3( 0, 0, -1),
// outside two clipping... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movq %rdi, %r12
movaps 0x4ef511(%rip), %xmm0 # 0xa3fcf0
movaps %xmm0, 0x2f0(%rsp)
movaps 0x4b7be2(%rip), %xmm0 # 0xa083d0
movaps %xmm0, 0x300(%rsp)
movaps 0x4ef503(%rip), %xmm0 # 0xa3fd00
movaps %xmm0, 0x3... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fClippingTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::PositionColorShader::shadeVertices(rr::VertexAttrib const*, rr::VertexPacket* const*, int) const | void PositionColorShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
const int positionAttrLoc = 0;
const int colorAttrLoc = 1;
rr::VertexPacket& packet = *packets[packetNdx];
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
testl %ecx, %ecx
jle 0x555aaa
movq %rdx, %r14
movq 0x10(%rsp), %rax
leaq 0x28(%rax), %r15
movl %ecx, %r13d
xorl %ebp, %ebp
movq %rsp, %r12
movq (%r14,%rbp,8), %rbx
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
xorps %xmm0,... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fPolygonOffsetTests.cpp |
deqp::gles3::Functional::reverifyConstantDerivateWithFlushRelaxations(tcu::TestLog&, tcu::ConstPixelBufferAccess const&, tcu::PixelBufferAccess const&, glu::DataType, glu::Precision, tcu::Vector<float, 4> const&, tcu::Vector<float, 4> const&, tcu::Vector<float, 4> const&, deqp::gles3::Functional::DerivateFunc, deqp::gl... | static bool reverifyConstantDerivateWithFlushRelaxations (tcu::TestLog& log,
const tcu::ConstPixelBufferAccess& result,
const tcu::PixelBufferAccess& errorMask,
glu::DataType dataType,
glu::Precision precision,
const tcu:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %r9, %r14
movl %r8d, %ebp
movq %rdx, 0x98(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x48(%rsp)
movaps 0x4e438b(%rip), %xmm0 # 0xa41f90
movups %xmm0, 0x190(%rsp)
movaps 0x4e438c(%rip), %xmm0 # 0xa41fa0
movu... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderDerivateTests.cpp |
deqp::gles3::Functional::TextureDerivateCase::init() | void TextureDerivateCase::init (void)
{
// Generate shader
{
const char* fragmentTmpl =
"#version 300 es\n"
"in highp vec2 v_coord;\n"
"layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
"uniform ${PRECISION} sampler2D u_sampler;\n"
"uniform ${PRECISION} ${DATATYPE} u_scale;\n"
"un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movl 0xe8(%rdi), %ebp
xorl %eax, %eax
cmpl $0x2, %ebp
leaq 0x48(%rsp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movl $0x22, %eax
movl $0x4, %edi
cmovel ... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderDerivateTests.cpp |
deqp::gles3::Functional::TextureDerivateCase::verify(tcu::ConstPixelBufferAccess const&, tcu::PixelBufferAccess const&) | void gen (void)
{
DE_ASSERT(!m_fbo);
m_gl.genFramebuffers(1, &m_fbo);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movl 0x8(%rsi), %r8d
cmpl $0x2, %r8d
jl 0x5602b4
movq %rsi, %r14
movl 0xc(%rsi), %r9d
cmpl $0x1, %r9d
jle 0x5602b4
movq %rdx, %r15
movq %rdi, %rbx
addl $-0x2, %r8d
addl $-0x2, %r9d
leaq 0xd8(%rsp), %rdi
movq %r1... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderDerivateTests.cpp |
deqp::gles3::Functional::LinearDerivateCase::~LinearDerivateCase() | ~LinearDerivateCase (void) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x6d4f95(%rip), %rax # 0xc36180
movq %rax, (%rdi)
movq 0xf8(%rdi), %rdi
leaq 0x108(%rbx), %rax
cmpq %rax, %rdi
je 0x56120c
movq (%rax), %rsi
incq %rsi
callq 0x3251a0
movq %rbx, %rdi
popq %rbx
jmp 0x560f8e
nop
| /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderDerivateTests.cpp |
deqp::gles3::Functional::DrawTests::init() | void DrawTests::init (void)
{
// Basic
{
const gls::DrawTestSpec::DrawMethod basicMethods[] =
{
gls::DrawTestSpec::DRAWMETHOD_DRAWARRAYS,
gls::DrawTestSpec::DRAWMETHOD_DRAWELEMENTS,
gls::DrawTestSpec::DRAWMETHOD_DRAWARRAYS_INSTANCED,
gls::DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_INSTANCED,
gls::DrawTe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorl %r13d, %r13d
leaq 0x6d5241(%rip), %r14 # 0xc364e0
leaq 0x4e2bba(%rip), %rax # 0xa43e60
movl (%r13,%rax), %ebp
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x865c18
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x86... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fDrawTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::genBasicSpec(deqp::gls::DrawTestSpec&, deqp::gls::DrawTestSpec::DrawMethod) | static void genBasicSpec (gls::DrawTestSpec& spec, gls::DrawTestSpec::DrawMethod method)
{
spec.apiType = glu::ApiType::es(3,0);
spec.primitive = gls::DrawTestSpec::PRIMITIVE_TRIANGLES;
spec.primitiveCount = 5;
spec.drawMethod = method;
spec.indexType = gls::DrawTestSpec::INDEXTYPE_LAST;
spec.indexP... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100000003, %rax # imm = 0x100000003
movq %rax, (%rdi)
movl $0x5, 0x8(%rdi)
movl %esi, 0xc(%rdi)
movaps 0x4e1e67(%rip), %xmm0 # 0xa439b0
movups %xmm0, 0x10(%rdi)
xorl %r14d, %r14d
movq %r14, 0x20(%rdi)
movl $0x1, 0x28(%rdi)
addq $0x38, %rdi
movl $0x2, %e... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fDrawTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::InstancedGridRenderTest::iterate() | InstancedGridRenderTest::IterateResult InstancedGridRenderTest::iterate (void)
{
const int renderTargetWidth = de::min(1024, m_context.getRenderTarget().getWidth());
const int renderTargetHeight = de::min(1024, m_context.getRenderTarget().getHeight());
sglr::GLContext ctx (m_context.getRenderContext(), m_testCtx.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x688, %rsp # imm = 0x688
movq %rdi, %r15
movq 0x70(%rdi), %rdi
callq 0x335b60
movl (%rax), %ebx
movl $0x400, %ebp # imm = 0x400
cmpl %ebp, %ebx
cmovgel %ebp, %ebx
movq 0x70(%r15), %rdi
callq 0x335b60
movl 0x4(%rax), %eax
cmpl... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fDrawTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::GridProgram::shadeFragments(rr::FragmentPacket*, int, rr::FragmentShadingContext const&) const | void GridProgram::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, rr::readTriangleV... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
testl %edx, %edx
jle 0x565b5a
movq %rcx, %rbx
movl %edx, %eax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
movq %rbp, %r12
shlq $0x6, %r12
addq 0x20(%rsp), %r12
xorl %r13d, %r13d
movq... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fDrawTests.cpp |
deqp::gles3::Functional::(anonymous namespace)::RandomGroup::init() | void RandomGroup::init (void)
{
const int numAttempts = 300;
static const int attribCounts[] = { 1, 2, 5 };
static const float attribWeights[] = { 30, 10, 1 };
static const int primitiveCounts[] = { 1, 5, 64 };
static const float primitiveCountWeights[] = { 20, 10, 1 };
static const int indexOffsets[] ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rdi, 0x68(%rsp)
xorl %eax, %eax
movl $0x3f800000, 0x27c(%rsp,%rax,4) # imm = 0x3F800000
incq %rax
cmpq $0x7, %rax
jne 0x565ba0
xorl %eax, %eax
movl $0x3f800000, 0xec(%rsp,%rax,4) # imm = 0x3F800000
incq %r... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fDrawTests.cpp |
deqp::gls::DrawTestSpec::DrawMethod de::Random::chooseWeighted<deqp::gls::DrawTestSpec::DrawMethod, deqp::gls::DrawTestSpec::DrawMethod const*, float const*>(deqp::gls::DrawTestSpec::DrawMethod const*, deqp::gls::DrawTestSpec::DrawMethod const*, float const*) | T Random::chooseWeighted (InputIter first, InputIter last, WeightIter weight)
{
// Compute weight sum
float weightSum = 0.0f;
int ndx;
for (ndx = 0; (first + ndx) != last; ndx++)
weightSum += *(weight + ndx);
// Random point in 0..weightSum
float p = getFloat(0.0f, weightSum);
// Find item in range
InputIt... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
xorps %xmm0, %xmm0
cmpq %rdx, %rsi
je 0x566983
movl $0x1, %eax
xorl %ecx, %ecx
addss (%r14,%rcx,4), %xmm0
movslq %eax, %rcx
leaq (%r15,%rcx,4), %rdx
incl %eax
cmpq %rbx, %rdx
jne 0x56696f
movss %xmm0, 0xc(%rsp)
callq 0x9fa... | /kaydenl[P]VK-GL-CTS/framework/delibs/decpp/deRandom.hpp |
deqp::gls::DrawTestSpec::InputType de::Random::chooseWeighted<deqp::gls::DrawTestSpec::InputType, deqp::gls::DrawTestSpec::InputType const*, float const*>(deqp::gls::DrawTestSpec::InputType const*, deqp::gls::DrawTestSpec::InputType const*, float const*) | T Random::chooseWeighted (InputIter first, InputIter last, WeightIter weight)
{
// Compute weight sum
float weightSum = 0.0f;
int ndx;
for (ndx = 0; (first + ndx) != last; ndx++)
weightSum += *(weight + ndx);
// Random point in 0..weightSum
float p = getFloat(0.0f, weightSum);
// Find item in range
InputIt... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
xorps %xmm0, %xmm0
cmpq %rdx, %rsi
je 0x566b81
movl $0x1, %eax
xorl %ecx, %ecx
addss (%r14,%rcx,4), %xmm0
movslq %eax, %rcx
leaq (%r15,%rcx,4), %rdx
incl %eax
cmpq %rbx, %rdx
jne 0x566b6d
movss %xmm0, 0xc(%rsp)
callq 0x9fa... | /kaydenl[P]VK-GL-CTS/framework/delibs/decpp/deRandom.hpp |
deqp::gles3::Functional::ShaderPackingFunctionCase::init() | void ShaderPackingFunctionCase::init (void)
{
DE_ASSERT(!m_executor);
m_executor = createExecutor(m_context.getRenderContext(), m_shaderType, m_spec);
m_testCtx.getLog() << m_executor;
if (!m_executor->isOk())
throw tcu::TestError("Compile failed");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movq 0x8(%rax), %rdi
movl 0x78(%rbx), %esi
leaq 0x80(%rbx), %rdx
callq 0x878341
movq %rax, 0xf8(%rbx)
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rsi
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq 0xf8(%rbx), %rdi
mo... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderPackingFunctionTests.cpp |
deqp::gles3::Functional::UnpackSnorm2x16Case::UnpackSnorm2x16Case(deqp::gles3::Context&, glu::ShaderType) | UnpackSnorm2x16Case (Context& context, glu::ShaderType shaderType)
: ShaderPackingFunctionCase(context, (string("unpacksnorm2x16") + getShaderTypePostfix(shaderType)).c_str(), "unpackSnorm2x16", shaderType)
{
m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));
m_spec.outpu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4dc9d1(%rip), %rsi # 0xa4445b
leaq 0x4dc9d9(%rip), %rdx # 0xa4446a
movq %rsp, %rdi
callq 0x334070
movl %ebp, %eax
leaq 0x6ced9e(%rip), %rcx ... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderPackingFunctionTests.cpp |
deqp::gles3::Functional::UnpackHalf2x16Case::UnpackHalf2x16Case(deqp::gles3::Context&, glu::ShaderType) | UnpackHalf2x16Case (Context& context, glu::ShaderType shaderType)
: ShaderPackingFunctionCase(context, (string("unpackhalf2x16") + getShaderTypePostfix(shaderType)).c_str(), "unpackHalf2x16", shaderType)
{
m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));
m_spec.outputs.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4dbd58(%rip), %rsi # 0xa44572
leaq 0x4dbd5f(%rip), %rdx # 0xa44580
movq %rsp, %rdi
callq 0x334070
movl %ebp, %eax
leaq 0x6ce00e(%rip), %rcx ... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderPackingFunctionTests.cpp |
deqp::gles3::Functional::UnpackSnorm2x16Case::iterate() | IterateResult iterate (void)
{
const deUint32 maxDiff = 1; // Rounding error.
de::Random rnd (deStringHash(getName()) ^ 0x776002);
std::vector<deUint32> inputs;
std::vector<tcu::Vec2> outputs;
inputs.push_back(0x00000000u);
inputs.push_back(0x7fff8000u);
inputs.push_back(0x80007fffu);
inpu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdi, %r13
movq 0x10(%rdi), %rdi
callq 0x9fa3f8
xorl $0x776002, %eax # imm = 0x776002
leaq 0x88(%rsp), %rdi
movl %eax, %esi
callq 0x9fa2bc
xorl %eax, %eax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
mo... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderPackingFunctionTests.cpp |
deqp::gles3::Functional::PackHalf2x16Case::iterate() | IterateResult iterate (void)
{
const int maxDiff = 0; // Values can be represented exactly in mediump.
de::Random rnd (deStringHash(getName()) ^ 0x776002);
std::vector<tcu::Vec2> inputs;
std::vector<deUint32> outputs;
// Special values to check.
inputs.push_back(tcu::Vec2(0.0f, 0.0f));
inpu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x9fa3f8
xorl $0x776002, %eax # imm = 0x776002
leaq 0x68(%rsp), %rdi
movl %eax, %esi
callq 0x9fa2bc
xorl %eax, %eax
leaq 0x10(%rsp), %rdi
movq %rax, 0x10(%rdi)... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderPackingFunctionTests.cpp |
deqp::gles3::Functional::operator<<(std::ostream&, deqp::gles3::Functional::HexBool const&) | std::ostream& operator<< (std::ostream& str, const HexBool& v)
{
return str << (v.value ? "true" : "false") << " / " << tcu::toHex(v.value);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %edx, %edx
cmpl $0x0, (%rsi)
sete %dl
leaq 0x53d0e0(%rip), %rax # 0xaa9327
leaq 0x53d2e6(%rip), %rsi # 0xaa9534
cmoveq %rax, %rsi
orq $0x4, %rdx
callq 0x325e70
leaq 0x4f354a(%rip), %rsi # 0xa5f7ac
movl $0x3, %edx
movq %rbx, %rdi
callq 0x325e... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderCommonFunctionTests.cpp |
deqp::gles3::Functional::BufferPartialMapWriteCase::iterate() | IterateResult iterate (void)
{
deUint32 dataSeed = deStringHash(getName());
ReferenceBuffer refBuf;
BufferVerifier verifier (m_renderCtx, m_testCtx.getLog(), m_verify);
// Setup reference data.
refBuf.setSize(m_bufferSize);
fillWithRandomBytes(refBuf.getPtr(), m_bufferSize, dataSeed);
deUint32 buf = g... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x9fa3f8
movl %eax, %r15d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rbx), %rax
movq 0x88(%rbx), %rsi
movq 0x10(%rax), %rdx
movl 0xd4(%rbx), %ecx
leaq 0x20(%rsp), %rdi
callq 0x8878d8
mov... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fBufferMapTests.cpp |
deqp::gles3::Functional::BufferMapInvalidateCase::iterate() | IterateResult iterate (void)
{
deUint32 dataSeed = deStringHash(getName());
deUint32 buf = 0;
ReferenceBuffer refBuf;
BufferVerifier verifier (m_renderCtx, m_testCtx.getLog(), m_verify);
const int bufferSize = 1300;
const int mapOffset = 200;
const int mapSize = 1011;
const int mapWriteO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x9fa3f8
movl %eax, %r13d
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x8(%rbx), %rax
movq 0x88(%rbx), %rsi
movq 0x10(%rax), %rdx
movl 0xcc(%rbx), %ecx
leaq 0x28(%rsp... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fBufferMapTests.cpp |
deqp::gles3::Functional::BufferMapPartialInvalidateCase::iterate() | IterateResult iterate (void)
{
deUint32 dataSeed = deStringHash(getName());
deUint32 buf = 0;
ReferenceBuffer refBuf;
BufferVerifier verifier (m_renderCtx, m_testCtx.getLog(), m_verify);
const int bufferSize = 1300;
const int mapOffset = 200;
const int mapSize = 1011;
const int mapWriteO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x9fa3f8
movl %eax, %r13d
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x8(%rbx), %rax
movq 0x88(%rbx), %rsi
movq 0x10(%rax), %rdx
movl 0xcc(%rbx), %ecx
leaq 0x28(%rsp... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fBufferMapTests.cpp |
deqp::gles3::Functional::BufferMapExplicitFlushCase::iterate() | IterateResult iterate (void)
{
deUint32 dataSeed = deStringHash(getName());
deUint32 buf = 0;
ReferenceBuffer refBuf;
BufferVerifier verifier (m_renderCtx, m_testCtx.getLog(), m_verify);
const int bufferSize = 1300;
const int mapOffset = 200;
const int mapSize = 1011;
const int sliceAOff... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x9fa3f8
movl %eax, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x8(%rbx), %rax
movq 0x88(%rbx), %rsi
movq 0x10(%rax), %rdx
movl 0xcc(%rbx), %ecx
leaq 0x8(%rsp),... | /kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fBufferMapTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::UploadSampleAnalyzeResult deqp::gles3::Performance::(anonymous namespace)::analyzeSampleResults<deqp::gles3::Performance::(anonymous namespace)::MapBufferRangeFlushDurationNoAlloc>(tcu::TestLog&, std::vector<deqp::gles3::Performance::(anonymous namespace)::UploadSampleRe... | static UploadSampleAnalyzeResult analyzeSampleResults (tcu::TestLog& log, const std::vector<UploadSampleResult<SampleType> >& samples, bool logBucketPerformance)
{
// Assume data is linear with some outliers, fit a line
const LineParametersWithConfidence theilSenFitting = fitLineToSamples(samples);
const t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xac8, %rsp # imm = 0xAC8
movq %rsi, %r14
movq %rdi, %r13
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
shrq $0x6, %rcx
leaq 0x4ec(%rsp), %rdi
movl $0x28, %r9d
xorl %edx, %edx
movl $0x1, %r8d
callq 0x642c3e
movq 0x8(%r14), %rsi
subq (%r14), %rs... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gls::LineParametersWithConfidence deqp::gles3::Performance::(anonymous namespace)::fitLineToSamples<deqp::gles3::Performance::(anonymous namespace)::MapBufferRangeFlushDurationNoAlloc>(std::vector<deqp::gles3::Performance::(anonymous namespace)::UploadSampleResult<deqp::gles3::Performance::(anonymous namespace)::... | static LineParametersWithConfidence fitLineToSamples (const std::vector<UploadSampleResult<DurationType> >& samples, int beginNdx, int endNdx, int step, deUint64 DurationType::*target = &DurationType::fitResponseDuration)
{
std::vector<tcu::Vec2> samplePoints;
for (int sampleNdx = beginNdx; sampleNdx < endNdx; sampl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl %ecx, %edx
jge 0x642ceb
movq %r9, %r14
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
leaq 0x8(%rsp), %rbx
movq $0x0, 0x8(%rs... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderSampleAnalyzeResult deqp::gles3::Performance::(anonymous namespace)::analyzeSampleResults<deqp::gles3::Performance::(anonymous namespace)::RenderUploadRenderReadDuration>(tcu::TestLog&, std::vector<deqp::gles3::Performance::(anonymous namespace)::RenderSampleResult... | static RenderSampleAnalyzeResult analyzeSampleResults (tcu::TestLog& log, const std::vector<RenderSampleResult<SampleType> >& samples)
{
// Assume data is linear with some outliers, fit a line
const LineParametersWithConfidence theilSenFitting = fitLineToSamples(samples);
const typename SampleTypeTraits<Sa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xac8, %rsp # imm = 0xAC8
movq %rsi, %r14
movq %rdi, %rbp
movq 0x8(%rsi), %rax
subq (%rsi), %rax
shrq $0x3, %rax
imull $0x38e38e39, %eax, %ecx # imm = 0x38E38E39
leaq 0x614(%rsp), %rdi
movl $0x30, %r9d
xorl %edx, %edx
movl $0x1, %r8d
cal... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gls::LineParametersWithConfidence deqp::gles3::Performance::(anonymous namespace)::fitLineToSamples<deqp::gles3::Performance::(anonymous namespace)::RenderUploadRenderReadDuration>(std::vector<deqp::gles3::Performance::(anonymous namespace)::RenderSampleResult<deqp::gles3::Performance::(anonymous namespace)::Rend... | static LineParametersWithConfidence fitLineToSamples (const std::vector<RenderSampleResult<DurationType> >& samples, int beginNdx, int endNdx, int step, deUint64 DurationType::*target = &DurationType::fitResponseDuration)
{
std::vector<tcu::Vec2> samplePoints;
for (int sampleNdx = beginNdx; sampleNdx < endNdx; sampl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl %ecx, %edx
jge 0x652ebb
movq %r9, %r14
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
leaq 0x8(%rsp), %rbx
movq $0x0, 0x8(%rs... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::SingleOperationStatistics deqp::gles3::Performance::(anonymous namespace)::calculateSingleOperationStatistics<deqp::gles3::Performance::(anonymous namespace)::RenderSampleResult<deqp::gles3::Performance::(anonymous namespace)::RenderUploadRenderReadDuration>>(std::vector... | SingleOperationStatistics calculateSingleOperationStatistics (const std::vector<T>& samples, deUint64 T::SampleType::*target)
{
SingleOperationStatistics stats;
std::vector<deUint64> values(samples.size());
for (int ndx = 0; ndx < (int)samples.size(); ++ndx)
values[ndx] = samples[ndx].duration.*target;
std::so... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
movq %rdi, %rbx
sarq $0x3, %rsi
movabsq $-0x71c71c71c71c71c7, %r12 # imm = 0x8E38E38E38E38E39
imulq %r12, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x66e90a
movq (%r15), %rdx
m... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderCase<deqp::gles3::Performance::(anonymous namespace)::UnrelatedUploadRenderReadDuration>::logAndSetTestResult(std::vector<deqp::gles3::Performance::(anonymous namespace)::RenderCase<deqp::gles3::Performance::(anonymous namespace)::UnrelatedUploadRenderReadDuration>... | void RenderCase<SampleType>::logAndSetTestResult (const std::vector<SampleResult>& results)
{
std::vector<RenderSampleResult<SampleType> > mappedResults;
mapResultsToRenderRateFormat(mappedResults, results);
{
const RenderSampleAnalyzeResult analysis = analyzeSampleResults(m_testCtx.getLog(), mappedResults);
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %r15 # imm = 0x8E38E38E38E38E39
imulq %rax, %r15
movq (%rs... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderCase<deqp::gles3::Performance::(anonymous namespace)::UnrelatedUploadRenderReadDuration>::init() | void RenderCase<SampleType>::init (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
RenderPerformanceTestBase::init();
// requirements
if (m_context.getRenderTarget().getWidth() < RENDER_AREA_SIZE ||
m_context.getRenderTarget().getHeight() < RENDER_AREA_SIZE)
throw tcu::NotSupp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
movq %rbx, %rdi
callq 0x6451ba
movq 0x70(%rbx), %rdi
callq 0x335b60
cmpl $0x80, (%rax)
jl 0x65452f
movq 0x70(%rbx), %rdi
callq... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gls::LineParametersWithConfidence deqp::gles3::Performance::(anonymous namespace)::fitLineToSamples<deqp::gles3::Performance::(anonymous namespace)::UnrelatedUploadRenderReadDuration>(std::vector<deqp::gles3::Performance::(anonymous namespace)::RenderSampleResult<deqp::gles3::Performance::(anonymous namespace)::U... | static LineParametersWithConfidence fitLineToSamples (const std::vector<RenderSampleResult<DurationType> >& samples, int beginNdx, int endNdx, int step, deUint64 DurationType::*target = &DurationType::fitResponseDuration)
{
std::vector<tcu::Vec2> samplePoints;
for (int sampleNdx = beginNdx; sampleNdx < endNdx; sampl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl %ecx, %edx
jge 0x659a66
movq %r9, %r14
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
leaq 0x8(%rsp), %rbx
movq $0x0, 0x8(%rs... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::SingleOperationStatistics deqp::gles3::Performance::(anonymous namespace)::calculateSingleOperationStatistics<deqp::gles3::Performance::(anonymous namespace)::RenderSampleResult<deqp::gles3::Performance::(anonymous namespace)::UnrelatedUploadRenderReadDuration>>(std::vec... | SingleOperationStatistics calculateSingleOperationStatistics (const std::vector<T>& samples, deUint64 T::SampleType::*target)
{
SingleOperationStatistics stats;
std::vector<deUint64> values(samples.size());
for (int ndx = 0; ndx < (int)samples.size(); ++ndx)
values[ndx] = samples[ndx].duration.*target;
std::so... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
movq %rdi, %rbx
sarq $0x3, %rsi
movabsq $0x6db6db6db6db6db7, %r12 # imm = 0x6DB6DB6DB6DB6DB7
imulq %r12, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x66e90a
movq (%r15), %rdx
mo... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::UploadWaitDrawCase::logAndSetTestResult() | void UploadWaitDrawCase::logAndSetTestResult (void)
{
int uploadStabilization;
int renderReadStabilization;
int renderStabilization;
int readStabilization;
bool temporallyStable;
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Samples", "Result samples");
logSamples();
}
{
const tcu::Scop... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp # imm = 0x808
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r14
leaq 0x160(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3a0a48(%rip), %rsi # 0x9fbf49
leaq 0x3a0a48(%rip), %rdx # 0x9fbf50
leaq 0x150(%rsp), %rdi
cal... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::UploadWaitDrawCase::findStabilizationSample(unsigned long deqp::gles3::Performance::(anonymous namespace)::UploadWaitDrawCase::Result::*, char const*) | int UploadWaitDrawCase::findStabilizationSample (deUint64 (UploadWaitDrawCase::Result::*target), const char* description)
{
std::vector<std::vector<deUint64> > sampleObservations(m_numMaxSwaps+1);
ThresholdComparer<deUint64> comparer;
comparer.relativeThreshold = 0.15f; // 15%
comparer.absoluteThreshold = 100; /... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, 0x40(%rsp)
movq %rsi, %r15
movq %rdi, %r14
movl 0x9c(%rdi), %eax
incl %eax
movslq %eax, %rsi
leaq 0x58(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x66f092
movl 0x9c(%r14), %ecx
testl %ecx, %ecx
movq %r14... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderCase<deqp::gles3::Performance::(anonymous namespace)::UploadRenderReadDuration>::~RenderCase() | RenderCase<SampleType>::~RenderCase (void)
{
deinit();
} | pushq %rbx
movq %rdi, %rbx
leaq 0x5e12dd(%rip), %rax # 0xc3f930
movq %rax, (%rdi)
callq 0x65f286
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x65e676
movq 0xc0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3251a0
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x65e691
movq 0xa8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3251a0
leaq 0x5e101... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderSampleAnalyzeResult deqp::gles3::Performance::(anonymous namespace)::analyzeSampleResults<deqp::gles3::Performance::(anonymous namespace)::UploadRenderReadDuration>(tcu::TestLog&, std::vector<deqp::gles3::Performance::(anonymous namespace)::RenderSampleResult<deqp:... | static RenderSampleAnalyzeResult analyzeSampleResults (tcu::TestLog& log, const std::vector<RenderSampleResult<SampleType> >& samples)
{
// Assume data is linear with some outliers, fit a line
const LineParametersWithConfidence theilSenFitting = fitLineToSamples(samples);
const typename SampleTypeTraits<Sa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xaa8, %rsp # imm = 0xAA8
movq %rsi, %r14
movq %rdi, %r13
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
shrq $0x6, %rcx
leaq 0x58c(%rsp), %rdi
movl $0x28, %r9d
xorl %edx, %edx
movl $0x1, %r8d
callq 0x6661be
movq 0x8(%r14), %rsi
subq (%r14), %rs... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gls::LineParametersWithConfidence deqp::gles3::Performance::(anonymous namespace)::fitLineToSamples<deqp::gles3::Performance::(anonymous namespace)::UploadRenderReadDuration>(std::vector<deqp::gles3::Performance::(anonymous namespace)::RenderSampleResult<deqp::gles3::Performance::(anonymous namespace)::UploadRend... | static LineParametersWithConfidence fitLineToSamples (const std::vector<RenderSampleResult<DurationType> >& samples, int beginNdx, int endNdx, int step, deUint64 DurationType::*target = &DurationType::fitResponseDuration)
{
std::vector<tcu::Vec2> samplePoints;
for (int sampleNdx = beginNdx; sampleNdx < endNdx; sampl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl %ecx, %edx
jge 0x66626b
movq %r9, %r14
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
leaq 0x8(%rsp), %rbx
movq $0x0, 0x8(%rs... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::SingleOperationStatistics deqp::gles3::Performance::(anonymous namespace)::calculateSingleOperationStatistics<deqp::gles3::Performance::(anonymous namespace)::RenderSampleResult<deqp::gles3::Performance::(anonymous namespace)::UploadRenderReadDuration>>(std::vector<deqp:... | SingleOperationStatistics calculateSingleOperationStatistics (const std::vector<T>& samples, deUint64 T::SampleType::*target)
{
SingleOperationStatistics stats;
std::vector<deUint64> values(samples.size());
for (int ndx = 0; ndx < (int)samples.size(); ++ndx)
values[ndx] = samples[ndx].duration.*target;
std::so... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x6, %rsi
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
callq 0x66e90a
movq (%r15), %rdx
movq 0x8(%r15), %rax
subq %rdx, %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x666336
movq 0x... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderCase<deqp::gles3::Performance::(anonymous namespace)::UploadRenderReadDurationWithUnrelatedUploadSize>::~RenderCase() | RenderCase<SampleType>::~RenderCase (void)
{
deinit();
} | pushq %rbx
movq %rdi, %rbx
leaq 0x5d93ad(%rip), %rax # 0xc3f9f0
movq %rax, (%rdi)
callq 0x667276
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x666666
movq 0xc0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3251a0
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x666681
movq 0xa8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3251a0
leaq 0x5d902... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::GenericUploadRenderTimeCase<deqp::gles3::Performance::(anonymous namespace)::UploadRenderReadDurationWithUnrelatedUploadSize>::init() | void GenericUploadRenderTimeCase<SampleType>::init (void)
{
// init parent
RenderCase<SampleType>::init();
// log
{
const char* const targetFunctionName = (m_drawMethod == DRAWMETHOD_DRAW_ARRAYS) ? ("drawArrays") : ("drawElements");
const int perVertexSize = (m_targetBuffer == TARGETBUFFER_INDEX) ? ((int)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, %r14
callq 0x667fc6
movl 0x88(%r14), %r15d
movl 0xcc(%r14), %ebx
movq %r14, %rdi
callq 0x668498
movl %eax, %r12d
xorl %eax, %eax
cmpl $0x1, %ebx
setne %al
leal (%rax,%rax,2), %ebx
addl $0x2, %ebx
movl... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderCase<deqp::gles3::Performance::(anonymous namespace)::UploadRenderReadDurationWithUnrelatedUploadSize>::deinit() | void RenderCase<SampleType>::deinit (void)
{
RenderPerformanceTestBase::deinit();
if (m_attributeBufferID)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_attributeBufferID);
m_attributeBufferID = 0;
}
if (m_indexBufferID)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x645638
cmpl $0x0, 0x8c(%rbx)
je 0x6672b8
leaq 0x8c(%rbx), %r14
movq 0x70(%rbx), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0x1, %edi
movq %r14, %rsi
callq *0x438(%rax)
movl $0x0, 0x8c(%rbx)
cmpl $0x0, 0x90(%rbx)
je 0x6672ee
leaq 0x90(%rbx... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderCase<deqp::gles3::Performance::(anonymous namespace)::UploadRenderReadDurationWithUnrelatedUploadSize>::logAndSetTestResult(std::vector<deqp::gles3::Performance::(anonymous namespace)::RenderCase<deqp::gles3::Performance::(anonymous namespace)::UploadRenderReadDura... | void RenderCase<SampleType>::logAndSetTestResult (const std::vector<SampleResult>& results)
{
std::vector<RenderSampleResult<SampleType> > mappedResults;
mapResultsToRenderRateFormat(mappedResults, results);
{
const RenderSampleAnalyzeResult analysis = analyzeSampleResults(m_testCtx.getLog(), mappedResults);
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq %rdi, %rbp
sarq $0x4, %rax
movabsq $-0x3333333333333333, %rbx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rbx
movq (%rs... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pBufferDataUploadTests.cpp |
tcu::LogSampleList::~LogSampleList() | LogSampleList (const std::string& name, const std::string& description)
: m_name (name)
, m_description (description)
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x66eeae
movq (%rax), %rsi
incq %rsi
callq 0x3251a0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x66eec6
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x3251a0
popq %rbx
retq
| /kaydenl[P]VK-GL-CTS/framework/common/tcuTestLog.hpp |
tcu::SampleBuilder::operator<<(int) | SampleBuilder& operator<< (int v) { m_values.push_back(Value((deInt64)v)); return *this; } | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq %esi, %rax
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x66eef7
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x10(%rbx)
jmp 0x66ef03
leaq 0x8(%rbx), %rdi
movq %rsp, %rdx
callq 0x66ef52
movq %rbx, %rax
addq $0x10, %rsp
... | /kaydenl[P]VK-GL-CTS/framework/common/tcuTestLog.hpp |
tcu::SampleBuilder::operator<<(float) | SampleBuilder& operator<< (float v) { m_values.push_back(Value((double)v)); return *this; } | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
movl $0x1, (%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x66ef3d
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x10(%rbx)
jmp 0x66ef49
leaq 0x8(%rbx), %rdi
movq %rsp, %rdx
callq 0x66ef52
movq %rbx, %rax
addq $0x10,... | /kaydenl[P]VK-GL-CTS/framework/common/tcuTestLog.hpp |
de::SharedPtr<deqp::gles3::Performance::(anonymous namespace)::OperatorPerformanceCase::InitialCalibration>::~SharedPtr() | inline void SharedPtr<T>::release (void)
{
if (m_state)
{
if (deAtomicDecrement32(&m_state->strongRefCount) == 0)
{
m_ptr = DE_NULL;
m_state->deletePtr();
}
if (deAtomicDecrement32(&m_state->weakRefCount) == 0)
{
delete m_state;
m_state = DE_NULL;
}
}
} | movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x671bce
pushq %rbx
movq %rdi, %rbx
lock
decl 0x8(%rax)
jne 0x671bac
movq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rbx), %rax
lock
decl 0xc(%rax)
jne 0x671bcd
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x671bc5
movq (%rdi), %rax
callq *0x8(%r... | /kaydenl[P]VK-GL-CTS/framework/delibs/decpp/deSharedPtr.hpp |
deqp::gles3::Performance::(anonymous namespace)::OperatorPerformanceCase::OperatorPerformanceCase(tcu::TestContext&, glu::RenderContext&, char const*, char const*, deqp::gles3::Performance::(anonymous namespace)::OperatorPerformanceCase::CaseType, int, de::SharedPtr<deqp::gles3::Performance::(anonymous namespace)::Oper... | OperatorPerformanceCase::OperatorPerformanceCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description,
CaseType caseType, int numWorkloads, const InitialCalibrationStorage& initialCalibrationStorage)
: tcu::TestCase (testCtx, tcu::NODETYPE_PERFORMANCE, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r12
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x3e6c6a(%rip), %r8 # 0xa58855
movl $0x4, %edx
callq 0x9a9adc
leaq 0x5cdf8c(%rip), %rax # 0xc3fb88
movq %rax, (%rbx)
movq %r14, 0x70(%rbx)
movl %ebp, 0x78(%rbx)
movq 0x8(%rbx), %rax
movq 0x1... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pShaderOperatorTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::OperatorPerformanceCase::deinit() | void OperatorPerformanceCase::deinit (void)
{
if (!m_attribBuffers.empty())
{
m_renderCtx.getFunctions().deleteBuffers((glw::GLsizei)m_attribBuffers.size(), &m_attribBuffers[0]);
m_attribBuffers.clear();
}
m_programs.clear();
} | pushq %rbx
movq %rdi, %rbx
movq 0x190(%rdi), %rax
cmpq 0x198(%rdi), %rax
je 0x672c26
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x190(%rbx), %rsi
movq 0x198(%rbx), %rdi
subq %rsi, %rdi
shrq $0x2, %rdi
callq *0x438(%rax)
movq 0x190(%rbx), %rax
cmpq %rax, 0x198(%rbx)
je 0x672c26
movq %rax, 0x198(%rbx)... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pShaderOperatorTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::OperatorPerformanceCase::iterate() | OperatorPerformanceCase::IterateResult OperatorPerformanceCase::iterate (void)
{
const TheilSenCalibrator::State calibratorState = m_calibrator.getState();
if (calibratorState != TheilSenCalibrator::STATE_FINISHED)
{
if (calibratorState == TheilSenCalibrator::STATE_RECOMPUTE_PARAMS)
m_calibrator.recomputeParam... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x848, %rsp # imm = 0x848
movq %rdi, %r12
leaq 0xe0(%rdi), %r14
movq %r14, %rdi
callq 0x7f2b40
cmpl $0x2, %eax
je 0x672d09
cmpl $0x1, %eax
je 0x672c7d
testl %eax, %eax
jne 0x672caa
movq %r14, %rdi
callq 0x7f2c3e
jmp 0x672caa
movl 0x108(%... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pShaderOperatorTests.cpp |
tcu::Vector<float, 2> deqp::gles3::Performance::mean<2>(std::vector<tcu::Vector<float, 2>, std::allocator<tcu::Vector<float, 2>>> const&) | static tcu::Vector<float, N> mean (const vector<tcu::Vector<float, N> >& data)
{
tcu::Vector<float, N> sum(0.0f);
for (int i = 0; i < (int)data.size(); i++)
sum += data[i];
return sum / tcu::Vector<float, N>((float)data.size());
} | movq %rdi, %rax
movq $0x0, -0x10(%rsp)
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
subq %rdx, %rcx
sarq $0x3, %rcx
testl %ecx, %ecx
jle 0x67a428
movl %ecx, %esi
andl $0x7fffffff, %esi # imm = 0x7FFFFFFF
xorl %edi, %edi
xorl %r8d, %r8d
movss (%rdx,%r8,4), %xmm0
addss -0x10(%rsp,%r8,4), %xmm0
movss %xmm0, -0x10(%rsp,%r8... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pShaderOperatorTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::FunctionCase::generateSingleProgramData(deqp::gles3::Performance::(anonymous namespace)::FunctionCase::ProgramID) const | FunctionCase::ProgramContext FunctionCase::generateSingleProgramData (ProgramID programID) const
{
const bool isVertexCase = m_caseType == CASETYPE_VERTEX;
const char* const precision = glu::getPrecisionName(m_precision);
const char* const returnTypeName = getDataTypeName(m_returnType);
const string retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x758, %rsp # imm = 0x758
movl %edx, 0x114(%rsp)
movq %rsi, %rbx
movq %rdi, 0x1c0(%rsp)
movl 0x78(%rsi), %eax
movl %eax, 0x60(%rsp)
movl 0x1f0(%rsi), %edi
callq 0x8bb7fe
movq %rax, %r15
movl 0x1c8(%rbx), %edi
callq 0x8bb810
movq %rax, 0x... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pShaderOperatorTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::StaticOccluderFragDepthCullCase::genOccluderGeometry() const | virtual ObjectData genOccluderGeometry (void) const { return Utils::quadWith(Utils::getStaticFragDepthFragmentShader(), 0.2f); } | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28(%rsp), %r14
movq $0x125, (%r14) # imm = 0x125
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x325a10
movq %rax, %r12
movq %rax, (%r15)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderCountCase::logAnalysis(std::vector<deqp::gles3::Performance::(anonymous namespace)::Sample, std::allocator<deqp::gles3::Performance::(anonymous namespace)::Sample>> const&) | void RenderCountCase::logAnalysis (const vector<Sample>& samples)
{
using namespace gls;
TestLog& log = m_testCtx.getLog();
int maxWorkload = 0;
vector<Vec2> testSamples (samples.size());
for (size_t ndx = 0; ndx < samples.size(); ndx++)
{
const Sample& sample = samples[ndx];
testSamples[ndx] = Vec2(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rbx
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x5, %rsi
leaq 0x70(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x57b636
movq (%r15), %rcx
cmpq... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::BaseCostCase::logDescription() | virtual void logDescription (void)
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Section("Description", "Test description");
log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage;
log << TestLog::Message << "Geometry consists of two fullsceen quads. The first (occl... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rbx
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3d85be(%rip), %rsi # 0xa6046a
leaq 0x3d85c2(%rip), %rdx # 0xa60475
leaq 0x20(%rsp), %rdi
callq 0x334070
leaq 0x10(%rsp), %r15
movq %r15, -0x10(... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderCountCase::calibrate() const | int RenderCountCase::calibrate (void) const
{
using namespace gls;
const glw::Functions& gl = m_renderCtx.getFunctions();
TestLog& log = m_testCtx.getLog();
const RenderData occluderGeometry (genOccluderGeometry(), m_renderCtx, log);
const RenderData occludedGeometry (genOccludedGeometry(), m_render... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rdi, %r14
movq 0x70(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r15
movq 0x8(%r14), %rax
movq 0x10(%rax), %rbx
movq (%r14), %rax
leaq 0x118(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::RenderCountCase::renderSample(deqp::gles3::Performance::(anonymous namespace)::RenderData const&, deqp::gles3::Performance::(anonymous namespace)::RenderData const&, int) const | Sample RenderCountCase::renderSample (const RenderData& occluder, const RenderData& occluded, int callcount) const
{
const glw::Functions& gl = m_renderCtx.getFunctions();
Sample sample;
deUint64 now = 0;
deUint64 prev = 0;
deUint8 buffer[4];
// Stabilize
{
gl.clear(GL_COLOR_BUFFER_BIT | GL_DE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x70(%rsi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r15
movl $0x4500, %edi # imm = 0x4500
callq *0x188(%rax)
movl $0xb71, %e... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::Utils::variableQuad(float) | inline ObjectData variableQuad (float depth)
{
return ObjectData(glu::makeVtxFragSources(getInstanceNoiseVertexShader(), getDepthAsRedFragmentShader()), getFullscreenQuad(depth));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movq %rdi, %rbx
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %r14
movq $0x145, (%r14) # imm = 0x145
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x325a10
movq %rax, %... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::Utils::getFullscreenQuadWithGradient(float, float) | vector<float> getFullscreenQuadWithGradient (float depth0, float depth1)
{
const float data[] =
{
+1.0f, +1.0f, depth0, 0.0f,
+1.0f, -1.0f, depth0, 1.0f,
-1.0f, -1.0f, depth1, 2.0f,
-1.0f, -1.0f, depth1, 0.0f,
-1.0f, +1.0f, depth1, 1.0f,
+1.0f, +1.0f, depth0, 2.0f,
};
return vector<float>(DE... | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movabsq $0x3f8000003f800000, %rax # imm = 0x3F8000003F800000
leaq 0x70(%rsp), %rdx
movq %rax, -0x60(%rdx)
movss %xmm0, -0x58(%rdx)
movabsq $0x3f80000000000000, %rcx # imm = 0x3F80000000000000
movq %rcx, -0x54(%rdx)
movl $0xbf800000, %ecx # imm = 0xBF800000
movl %ecx, -0... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::OccludingGeometryComplexityCostCase::logDescription() | virtual void logDescription (void)
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Section("Description", "Test description");
log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage;
log << TestLog::Message << "Geometry consists of an occluding grid and an occluded fu... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rbx
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3d7466(%rip), %rsi # 0xa6046a
leaq 0x3d746a(%rip), %rdx # 0xa60475
leaq 0x20(%rsp), %rdi
callq 0x334070
leaq 0x10(%rsp), %r15
movq %r15, -0x10(... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::OccludingGeometryComplexityCostCase::genOccluderGeometry() const | virtual ObjectData genOccluderGeometry (void) const
{
return ObjectData(Utils::getBaseShader(),
Utils::getFullScreenGrid(m_resolution,
deInt32Hash(deStringHash(getName())) ^ m_testCtx.getCommandLine().getBaseSeed(),
0.2f,
m_zNoise,
m_xyNoise));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %r15
movq %rdi, %r13
leaq 0x128(%rsp), %rdi
callq 0x684667
movl 0xc8(%r15), %eax
movq %rax, 0x8(%rsp)
movq 0x10(%r15), %rdi
callq 0x9fa3f8
movl %eax, %r14d
movq 0x8(%r15), %rax
movq 0x18(%rax), %rdi
c... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::OccluderStaticFragDepthCostCase::logDescription() | virtual void logDescription (void)
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Section("Description", "Test description");
log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage;
log << TestLog::Message << "Geometry consists of two fullsceen quads. The first (... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rbx
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3d6c1c(%rip), %rsi # 0xa6046a
leaq 0x3d6c20(%rip), %rdx # 0xa60475
leaq 0x20(%rsp), %rdi
callq 0x334070
leaq 0x10(%rsp), %r15
movq %r15, -0x10(... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::BaseCase::~BaseCase() | virtual ~BaseCase (void) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x5b5a87(%rip), %rax # 0xc3fe80
movq %rax, (%rdi)
movq 0xa8(%rdi), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x68a41a
movq (%rax), %rsi
incq %rsi
callq 0x3251a0
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x68a438
movq (%rax), %rsi
incq %rsi
callq 0x3251a0
movq ... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::OccludedDynamicFragDepthCostCase::logDescription() | virtual void logDescription (void)
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Section("Description", "Test description");
log << TestLog::Message << "Testing hidden fragment culling speed" << TestLog::EndMessage;
log << TestLog::Message << "Geometry consists of two fullsceen quads. The first (... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rbx
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3d5fec(%rip), %rsi # 0xa6046a
leaq 0x3d5ff0(%rip), %rdx # 0xa60475
leaq 0x20(%rsp), %rdi
callq 0x334070
leaq 0x10(%rsp), %r15
movq %r15, -0x10(... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Performance::(anonymous namespace)::OccludedDynamicFragDepthCostCase::genOccludedGeometry() const | virtual ObjectData genOccludedGeometry (void) const { return Utils::quadWith(Utils::getDynamicFragDepthFragmentShader(), 0.2f); } | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28(%rsp), %r14
movq $0x150, (%r14) # imm = 0x150
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x325a10
movq %rax, %r12
movq %rax, (%r15)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles3/performance/es3pDepthTests.cpp |
deqp::gles3::Stress::(anonymous namespace)::TextureSamplerCase::init() | void TextureSamplerCase::init (void)
{
// requirements
{
GLint maxTextureSize = 0;
m_context.getRenderContext().getFunctions().getIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
if (maxTextureSize < TEST_TEXTURE_SIZE)
throw tcu::NotSupportedError(std::string("GL_MAX_TEXTURE_SIZE must be at least ") + de::toS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %r12
leaq 0x14(%rsp), %rbx
movl $0x0, (%rbx)
movq 0x70(%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0xd33, %edi # imm = 0xD33
movq %rbx, %rsi
callq *0x868(%rax... | /kaydenl[P]VK-GL-CTS/modules/gles3/stress/es3sSpecialFloatTests.cpp |
void deqp::gls::BuiltinPrecisionTests::addScalarFactory<deqp::gls::BuiltinPrecisionTests::Functions::ASin>(deqp::gls::BuiltinPrecisionTests::BuiltinFuncs&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void addScalarFactory(BuiltinFuncs& funcs, string name = "")
{
if (name.empty())
name = instance<F>().getName();
funcs.addFactory(SharedPtr<const CaseFactory>(new GenFuncCaseFactory<typename F::Sig>(
makeVectorizedFuncs<F>(), name)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
jne 0x6a94ac
callq 0x7d391a
movq (%rax), %rcx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x325800
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::addScalarFactory<deqp::gls::BuiltinPrecisionTests::Functions::Sinh>(deqp::gls::BuiltinPrecisionTests::BuiltinFuncs&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void addScalarFactory(BuiltinFuncs& funcs, string name = "")
{
if (name.empty())
name = instance<F>().getName();
funcs.addFactory(SharedPtr<const CaseFactory>(new GenFuncCaseFactory<typename F::Sig>(
makeVectorizedFuncs<F>(), name)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
jne 0x6a9ad0
callq 0x7cd070
movq (%rax), %rcx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x325800
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::addScalarFactory<deqp::gls::BuiltinPrecisionTests::Functions::Tanh>(deqp::gls::BuiltinPrecisionTests::BuiltinFuncs&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void addScalarFactory(BuiltinFuncs& funcs, string name = "")
{
if (name.empty())
name = instance<F>().getName();
funcs.addFactory(SharedPtr<const CaseFactory>(new GenFuncCaseFactory<typename F::Sig>(
makeVectorizedFuncs<F>(), name)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
jne 0x6a9de2
callq 0x7cd5b4
movq (%rax), %rcx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x325800
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::addScalarFactory<deqp::gls::BuiltinPrecisionTests::Functions::ACosh>(deqp::gls::BuiltinPrecisionTests::BuiltinFuncs&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void addScalarFactory(BuiltinFuncs& funcs, string name = "")
{
if (name.empty())
name = instance<F>().getName();
funcs.addFactory(SharedPtr<const CaseFactory>(new GenFuncCaseFactory<typename F::Sig>(
makeVectorizedFuncs<F>(), name)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
jne 0x6aa0f4
callq 0x7cd9ab
movq (%rax), %rcx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x325800
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::addScalarFactory<deqp::gls::BuiltinPrecisionTests::Functions::Log>(deqp::gls::BuiltinPrecisionTests::BuiltinFuncs&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void addScalarFactory(BuiltinFuncs& funcs, string name = "")
{
if (name.empty())
name = instance<F>().getName();
funcs.addFactory(SharedPtr<const CaseFactory>(new GenFuncCaseFactory<typename F::Sig>(
makeVectorizedFuncs<F>(), name)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
jne 0x6aa718
callq 0x7cbfc2
movq (%rax), %rcx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x325800
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::addScalarFactory<deqp::gls::BuiltinPrecisionTests::Functions::Sqrt>(deqp::gls::BuiltinPrecisionTests::BuiltinFuncs&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void addScalarFactory(BuiltinFuncs& funcs, string name = "")
{
if (name.empty())
name = instance<F>().getName();
funcs.addFactory(SharedPtr<const CaseFactory>(new GenFuncCaseFactory<typename F::Sig>(
makeVectorizedFuncs<F>(), name)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
jne 0x6aabb3
callq 0x7cc11a
movq (%rax), %rcx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x325800
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::addScalarFactory<deqp::gls::BuiltinPrecisionTests::Functions::Mod>(deqp::gls::BuiltinPrecisionTests::BuiltinFuncs&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void addScalarFactory(BuiltinFuncs& funcs, string name = "")
{
if (name.empty())
name = instance<F>().getName();
funcs.addFactory(SharedPtr<const CaseFactory>(new GenFuncCaseFactory<typename F::Sig>(
makeVectorizedFuncs<F>(), name)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
jne 0x6abb0d
callq 0x7d0dc8
movq (%rax), %rcx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x325800
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::addScalarFactory<deqp::gls::BuiltinPrecisionTests::Functions::Step>(deqp::gls::BuiltinPrecisionTests::BuiltinFuncs&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void addScalarFactory(BuiltinFuncs& funcs, string name = "")
{
if (name.empty())
name = instance<F>().getName();
funcs.addFactory(SharedPtr<const CaseFactory>(new GenFuncCaseFactory<typename F::Sig>(
makeVectorizedFuncs<F>(), name)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
jne 0x6ac3e8
callq 0x7d85de
movq (%rax), %rcx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x325800
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::VariableP<float>::operator deqp::gls::BuiltinPrecisionTests::ExprP<float>() const | operator ExprP<T> (void) const { return exprP(SharedPtr<const Expr<T> >(*this)); } | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x6b0c7c
lock
incl 0x8(%rax)
movq 0x8(%rsp), %rax
lock
incl 0xc(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6b0b92
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x6b0cce
lock
decl 0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::VariableP<tcu::Vector<float, 2>>::VariableP(deqp::gls::BuiltinPrecisionTests::Variable<tcu::Vector<float, 2>> const*) | explicit VariableP (const Variable<T>* ptr) : Super(ptr) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, (%rdi)
movl $0x20, %edi
callq 0x325210
xorl %ecx, %ecx
movl %ecx, 0x8(%rax)
movl %ecx, 0xc(%rax)
leaq 0x58b93c(%rip), %rcx # 0xc422e8
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x8(%rbx)
movl $... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::DerivedFunc<deqp::gls::BuiltinPrecisionTests::Signature<float, tcu::Vector<float, 2>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doPrintDefinition(std::ostream&) const | void doPrintDefinition (ostream& os) const
{
const ParamNames& paramNames = this->getParamNames();
initialize();
os << dataTypeNameOf<Ret>() << " " << this->getName()
<< "(";
if (isTypeValid<Arg0>())
os << dataTypeNameOf<Arg0>() << " " << paramNames.a;
if (isTypeValid<Arg1>())
os << ", " << d... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %r15
movq %r14, %rdi
callq 0x6b8b2a
movl $0x1, %edi
callq 0x8bb810
testq %rax, %rax
je 0x6b8420
movq %rax, %r12
movq %rax, %rdi
callq 0x325680
movq %rbx, %rdi
movq %r12, %rsi
movq ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::DerivedFunc<deqp::gls::BuiltinPrecisionTests::Signature<float, tcu::Vector<float, 2>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doApply(deqp::gls::BuiltinPrecisionTests::EvalContext const&, deqp::gls::Built... | IRet doApply (const EvalContext& ctx,
const IArgs& args) const
{
Environment funEnv;
IArgs& mutArgs = const_cast<IArgs&>(args);
IRet ret;
initialize();
funEnv.bind(*m_var0, args.a);
funEnv.bind(*m_var1, args.b);
funEnv.bind(*m_var2, args.c);
funEnv.bind(*m_var3, args.d);
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movb $0x0, (%rdi)
movabsq $0x7f... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::Apply<deqp::gls::BuiltinPrecisionTests::Signature<float, tcu::Vector<float, 3>, int, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doEvaluate(deqp::gls::BuiltinPrecisionTests::EvalContext const&) const | IVal doEvaluate (const EvalContext& ctx) const
{
return m_func.apply(ctx,
m_args.a->evaluate(ctx), m_args.b->evaluate(ctx),
m_args.c->evaluate(ctx), m_args.d->evaluate(ctx));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rsi
movq (%rsi), %rax
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq *0x20(%rax)
movq 0x20(%r12), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rbp
movq %rbp, ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::Functions::GetComponent<tcu::Vector<float, 3>>::print(std::ostream&, std::vector<deqp::gls::BuiltinPrecisionTests::ExprBase const*, std::allocator<deqp::gls::BuiltinPrecisionTests::ExprBase const*>> const&) const | void print (ostream& os,
const BaseArgExprs& args) const
{
os << *args[0] << "[" << *args[1] << "]";
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x387d04(%rip), %rsi # 0xa4a151
movl $0x1, %edx
movq %rbx, %rdi
callq 0x325e70
movq (%r14), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
leaq ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::Apply<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Vector<float, 3>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doGetUsedFuncs(std::set<deqp::gls::BuiltinPrecisionTests::FuncBase c... | void doGetUsedFuncs (FuncSet& dst) const
{
m_func.getUsedFuncs(dst);
m_args.a->getUsedFuncs(dst);
m_args.b->getUsedFuncs(dst);
m_args.c->getUsedFuncs(dst);
m_args.d->getUsedFuncs(dst);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx,... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::ApplyVar<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Vector<float, 3>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doEvaluate(deqp::gls::BuiltinPrecisionTests::EvalContext const&) ... | IVal doEvaluate (const EvalContext& ctx) const
{
const Variable<Arg0>& var0 = static_cast<const Variable<Arg0>&>(*this->m_args.a);
const Variable<Arg1>& var1 = static_cast<const Variable<Arg1>&>(*this->m_args.b);
const Variable<Arg2>& var2 = static_cast<const Variable<Arg2>&>(*this->m_args.c);
const Variab... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rax
movq 0x20(%rsi), %r12
movq 0x30(%rsi), %r13
movq 0x40(%rsi), %rcx
movq %rcx, (%rsp)
movq 0x30(%rdx), %rdi
movq %rax, %rsi
callq 0x6bdea6
movq %rax, %rbp
movq 0x30... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.