name string | code string | asm string | file string |
|---|---|---|---|
deqp::gls::ShaderExecUtil::generateFragShaderOutputDecl(std::ostream&, deqp::gls::ShaderExecUtil::ShaderSpec const&, bool, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocat... | static void generateFragShaderOutputDecl (std::ostream& src, const ShaderSpec& shaderSpec, bool useIntOutputs, const std::map<std::string, int>& outLocationMap, const std::string& outputPrefix)
{
DE_ASSERT(glu::glslVersionUsesInOutQualifiers(shaderSpec.version));
for (int outNdx = 0; outNdx < (int)shaderSpec.outputs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq %r8, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x20(%rsi), %r13
movq %rsi, 0xa0(%rsp)
movq 0x28(%rsi), %rax
subq %r13, %rax
shrq $0x3, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::generateFragShaderOutAssign(std::ostream&, deqp::gls::ShaderExecUtil::ShaderSpec const&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void generateFragShaderOutAssign (std::ostream& src, const ShaderSpec& shaderSpec, bool useIntOutputs, const std::string& valuePrefix, const std::string& outputPrefix)
{
for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output)
{
if (useIntOutputs ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
movq 0x20(%rsi), %rbx
movq %rsi, 0x8(%rsp)
cmpq 0x28(%rsi), %rbx
je 0x878ea6
movq %r8, %rbp
movq %rcx, %r14
movq %rdi, %r12
movq %r8, 0x10(%rsp)
cmpb $0x0, 0x4(%rsp)
je 0x878b62
movl 0x28(%rbx), %eax
decl %eax
cmpl $... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::mapped_type cons... | const typename M::mapped_type& lookup (const M& map, const typename M::key_type& key)
{
const typename M::mapped_type* ptr = tryLookup(map, key);
if (ptr == DE_NULL)
throw std::out_of_range("key not found in map");
return *ptr;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x879130
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x878f93
addq $0x40, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x325650
movq %rax, %rbx
leaq 0x1eeaec(%rip), %rsi # 0xa67a93
movq %rax, %rdi
callq 0x3253d0
movq 0x3e393a(%rip), %rsi # 0xc5... | /kaydenl[P]VK-GL-CTS/framework/delibs/decpp/deSTLUtil.hpp |
bool de::insert<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>>(... | bool insert (M& map, const typename M::key_type& key, const typename M::mapped_type& value)
{
typename M::value_type entry(key, value);
std::pair<typename M::iterator,bool> ret = map.insert(entry);
return ret.second;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x334442
movl (%rbx), %eax
movl %eax, 0x20(%r15)
movq %r14, %rdi
movq %r1... | /kaydenl[P]VK-GL-CTS/framework/delibs/decpp/deSTLUtil.hpp |
deqp::gls::TextureSamplerTest::setTextureState(glw::Functions const&, unsigned int, deqp::gls::TextureSamplerTest::SamplingState) | void TextureSamplerTest::setTextureState (const glw::Functions& gl, GLenum target, SamplingState state)
{
gl.texParameteri(target, GL_TEXTURE_MIN_FILTER, state.minFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri(target, GL_TEXTURE_MIN_FILTER, state.minFilter)");
gl.texParameteri(target, GL_TEXTURE_MAG_FI... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x20(%rsp), %edx
movl %esi, %edi
movl $0x2801, %esi # imm = 0x2801
callq *0x1360(%rbx)
callq *0x800(%rbx)
leaq 0x20e007(%rip), %rsi # 0xa878d0
leaq 0x20e040(%rip), %r14 # 0xa87910
movl %eax, %edi
movq %r14, %rdx
movl $0x56, %ecx
callq... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsSamplerObjectTest.cpp |
deqp::gls::TextureSamplerTest::selectVertexShader(unsigned int) | const char* TextureSamplerTest::selectVertexShader (GLenum target)
{
switch (target)
{
case GL_TEXTURE_2D:
return
"${VTX_HDR}"
"${VTX_IN} ${HIGHP} vec2 a_position;\n"
"uniform ${HIGHP} float u_posScale;\n"
"${VTX_OUT} ${MEDIUMP} vec2 v_texCoord;\n"
"void main (void)\n"
"{\n"
"\tv_texCoord = ... | cmpl $0xde1, %edi # imm = 0xDE1
je 0x879b72
cmpl $0x8513, %edi # imm = 0x8513
je 0x879b6a
cmpl $0x806f, %edi # imm = 0x806F
jne 0x879b7a
leaq 0x20e216(%rip), %rax # 0xa87d7f
retq
leaq 0x20e2f0(%rip), %rax # 0xa87e61
retq
leaq 0x20e127(%rip), %rax # 0xa87ca0
retq
xorl %eax, %eax
r... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsSamplerObjectTest.cpp |
deqp::gls::TextureSamplerTest::createTexture(glw::Functions const&, unsigned int) | GLuint TextureSamplerTest::createTexture (const glw::Functions& gl, GLenum target)
{
switch (target)
{
case GL_TEXTURE_2D:
return createTexture2D(gl);
case GL_TEXTURE_3D:
return createTexture3D(gl);
case GL_TEXTURE_CUBE_MAP:
return createTextureCube(gl);
default:
DE_ASSERT(false);
return (GL... | cmpl $0x8513, %esi # imm = 0x8513
je 0x87b50f
cmpl $0x806f, %esi # imm = 0x806F
je 0x87b088
cmpl $0xde1, %esi # imm = 0xDE1
jne 0x87b519
jmp 0x87aed6
pushq %rax
callq 0x87b240
addq $0x8, %rsp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
nop
| /kaydenl[P]VK-GL-CTS/modules/glshared/glsSamplerObjectTest.cpp |
deqp::gls::TextureSamplerTest::iterate() | tcu::TestCase::IterateResult TextureSamplerTest::iterate (void)
{
tcu::TestLog& log = m_testCtx.getLog();
tcu::Surface textureRef(VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
tcu::Surface samplerRef(VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
tcu::Surface textureResult(VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
tcu::Surface samplerResult(VIE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r14
leaq 0x58(%rsp), %rdi
movl $0x80, %esi
movl $0x80, %edx
callq 0x9a957c
leaq 0x40(%rsp), %rdi
movl $0x80, %esi
movl $0x80, %edx
callq 0x9a957c
leaq 0x28(%rsp), %rdi
movl $0x80, %esi
movl $0x... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsSamplerObjectTest.cpp |
deqp::gls::MultiTextureSamplerTest::setSamplerState(glw::Functions const&, deqp::gls::MultiTextureSamplerTest::SamplingState, unsigned int) | void MultiTextureSamplerTest::setSamplerState (const glw::Functions& gl, SamplingState state, GLuint sampler)
{
gl.samplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, state.minFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, state.minFilter)");
gl.samplerParameteri(sampl... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x20(%rsp), %edx
movl %esi, %edi
movl $0x2801, %esi # imm = 0x2801
callq *0x1280(%rbx)
callq *0x800(%rbx)
leaq 0x20bc70(%rip), %rsi # 0xa87ae1
leaq 0x20ba98(%rip), %r14 # 0xa87910
movl %eax, %edi
movq %r14, %rdx
movl $0x268, %ecx ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsSamplerObjectTest.cpp |
deqp::gls::MultiTextureSamplerTest::render() | void MultiTextureSamplerTest::render (void)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
GLuint samplerLoc1 = (GLuint)-1;
GLuint samplerLoc2 = (GLuint)-1;
GLuint scaleLoc = (GLuint)-1;
gl.useProgram(m_program->getProgram());
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram(m_program->getProgram())")... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
movq 0x78(%rbx), %rax
movl 0x98(%rax), %edi
callq *0x1680(%r14)
callq *0x800(%r14)
leaq 0x19d02e(%rip), %rsi # 0xa19c78
leaq 0x20acbf(%rip), %rd... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsSamplerObjectTest.cpp |
deqp::gls::MultiTextureSamplerTest::createTextureCube(glw::Functions const&, int) | GLuint MultiTextureSamplerTest::createTextureCube (const glw::Functions& gl, int id)
{
GLuint texture = (GLuint)-1;
tcu::TextureCube refTexture (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), CUBEMAP_SIZE);
gl.genTextures(1, &texture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTex... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2c(%rsp), %r14
movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF
movabsq $0x300000008, %rax # imm = 0x300000008
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
movl $0x20, %edx
callq ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsSamplerObjectTest.cpp |
deqp::gls::MultiTextureSamplerTest::renderResults(tcu::Surface&, tcu::Surface&, int, int) | void MultiTextureSamplerTest::renderResults (tcu::Surface& textureResult, tcu::Surface& samplerResult, int x, int y)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
GLuint texture1 = createTexture(gl, m_target, 0);
GLuint texture2 = createTexture(gl, m_target, 1);
GLuint sampler = -1;
gl.v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, %rbp
movq %rsi, 0x48(%rsp)
movq %rdi, %r14
movq 0x70(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rbx
movl 0x80(%r14), %esi
movq %rax, %rdi
xorl %edx, %edx
callq 0x87db76
movl %... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsSamplerObjectTest.cpp |
deqp::gls::MultiTextureSamplerTest::iterate() | tcu::TestCase::IterateResult MultiTextureSamplerTest::iterate (void)
{
tcu::TestLog& log = m_testCtx.getLog();
tcu::Surface textureRef(VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
tcu::Surface samplerRef(VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
tcu::Surface textureResult(VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
tcu::Surface samplerResul... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r14
leaq 0x58(%rsp), %rdi
movl $0x80, %esi
movl $0x80, %edx
callq 0x9a957c
leaq 0x40(%rsp), %rdi
movl $0x80, %esi
movl $0x80, %edx
callq 0x9a957c
leaq 0x28(%rsp), %rdi
movl $0x80, %esi
movl $0x... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsSamplerObjectTest.cpp |
deqp::gls::ShaderPerformanceMeasurer::render(int) | void ShaderPerformanceMeasurer::render (int numDrawCalls)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
GLsizei numIndices = (GLsizei)getNumIndices(m_gridSizeX, m_gridSizeY);
gl.viewport(0, 0, m_viewportWidth, m_viewportHeight);
for (int callNdx = 0; callNdx < numDrawCalls; callNdx++)
gl.drawEl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
movl 0x8(%r15), %r12d
movl 0x10(%r15), %edx
imull 0xc(%r15), %r12d
movl 0x14(%r15), %ecx
xorl %edi, %edi
xorl %esi, %esi
callq *0x1a00(%rax)
testl %ebx, %ebx
jle 0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderPerformanceMeasurer.cpp |
deqp::gls::InteractionTestUtil::getRandomColor(de::Random&) | static Vec4 getRandomColor (de::Random& rnd)
{
static const float components[] = { 0.0f, 0.2f, 0.4f, 0.5f, 0.6f, 0.8f, 1.0f };
float r = rnd.choose<float>(DE_ARRAY_BEGIN(components), DE_ARRAY_END(components));
float g = rnd.choose<float>(DE_ARRAY_BEGIN(components), DE_ARRAY_END(components));
float b = rnd.choose<fl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movl %ebp, (%r13)
leaq 0x2086bc(%rip), %r15 # 0xa89070
leaq 0x2086d1(%rip), %r12 # 0xa8908c
movq %rsi, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl $... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsInteractionTestUtil.cpp |
deqp::gls::FragOpInteractionCase::deinit() | void FragOpInteractionCase::deinit (void)
{
delete m_referenceCtx;
m_referenceCtx = DE_NULL;
delete m_glCtx;
m_glCtx = DE_NULL;
delete m_program;
m_program = DE_NULL;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x440(%rdi), %r14
testq %r14, %r14
je 0x8812d4
leaq 0xd0(%r14), %rdi
callq 0x8a13b4
leaq 0x58(%r14), %r15
leaq 0xa8(%r14), %rdi
callq 0x9b433a
leaq 0x80(%r14), %rdi
callq 0x9b433a
movq %r15, %rdi
callq 0x9b433a
movq 0x38(%r14), %rdi
leaq 0x48(%r14), %rax
cmpq %rax, ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsFragOpInteractionCase.cpp |
deqp::gls::FragOpInteractionCase::init() | void FragOpInteractionCase::init (void)
{
de::Random rnd (m_params.seed ^ 0x232faac);
const int viewportW = de::min<int>(m_renderCtx.getRenderTarget().getWidth(), VIEWPORT_WIDTH);
const int viewportH = de::min<int>(m_renderCtx.getRenderTarget().getHeight(), VIEWPORT_HEIGHT);
const int viewportX = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x80(%rdi), %rax
movq %rax, 0x10(%rsp)
movl $0x232faac, %esi # imm = 0x232FAAC
xorl 0x80(%rdi), %esi
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x9fa2bc
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%ra... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsFragOpInteractionCase.cpp |
deqp::gls::StateChangePerformanceCase::deinit() | void StateChangePerformanceCase::deinit (void)
{
m_indices.clear();
m_interleavedResults.clear();
m_batchedResults.clear();
{
const glw::Functions& gl = m_renderCtx.getFunctions();
if (!m_indexBuffers.empty())
{
gl.deleteBuffers((GLsizei)m_indexBuffers.size(), &(m_indexBuffers[0]));
m_indexBuffers.cle... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x148(%rdi), %rax
cmpq %rax, 0x150(%rdi)
je 0x883877
movq %rax, 0x150(%rbx)
movq 0x160(%rbx), %rax
cmpq %rax, 0x168(%rbx)
je 0x88388e
movq %rax, 0x168(%rbx)
movq 0x178(%rbx), %rax
cmpq %rax, 0x180(%rbx)
je 0x8838a5
movq %rax, 0x180(%rbx)
movq 0x70(%rbx), %rdi
movq (... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsStateChangePerfTestCases.cpp |
deqp::gls::StateChangePerformanceCase::callDraw(glw::Functions const&) | void StateChangePerformanceCase::callDraw (const glw::Functions& gl)
{
switch (m_drawType)
{
case DRAWTYPE_NOT_INDEXED: gl.drawArrays(GL_TRIANGLES, 0, m_triangleCount * 3); break;
case DRAWTYPE_INDEXED_USER_PTR: gl.drawElements(GL_TRIANGLES, m_triangleCount * 3, GL_UNSIGNED_SHORT, &m_indices[0]); break;
... | movl 0x78(%rdi), %eax
cmpl $0x2, %eax
je 0x885d2d
cmpl $0x1, %eax
je 0x885d0a
testl %eax, %eax
jne 0x885d4b
movq 0x538(%rsi), %rax
movl 0x84(%rdi), %ecx
leal (%rcx,%rcx,2), %edx
movl $0x4, %edi
xorl %esi, %esi
jmpq *%rax
movq 0x568(%rsi), %rax
movl 0x84(%rdi), %ecx
leal (%rcx,%rcx,2), %esi
movq 0x148(%rdi), %rcx
movl $... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsStateChangePerfTestCases.cpp |
deqp::gls::StateChangeCallPerformanceCase::iterate() | tcu::TestCase::IterateResult StateChangeCallPerformanceCase::iterate (void)
{
if (m_results.empty())
logTestCase();
if ((int)m_results.size() < m_iterationCount)
{
executeTest();
GLU_EXPECT_NO_ERROR(m_renderCtx.getFunctions().getError(), "Unexpected error");
return CONTINUE;
}
else
{
logAndSetTestResul... | pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq 0x88(%rdi), %rax
jne 0x8865f4
movq %rbx, %rdi
callq 0x885e58
movq 0x88(%rbx), %rax
subq 0x80(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, 0x78(%rbx)
jle 0x886644
movq %rbx, %rdi
callq 0x885dce
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
callq *0x800(%rax)
le... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsStateChangePerfTestCases.cpp |
deqp::gls::BufferTestUtil::getUsageHintName(unsigned int) | const char* getUsageHintName (deUint32 hint)
{
switch (hint)
{
case GL_STREAM_DRAW: return "stream_draw";
case GL_STREAM_READ: return "stream_read";
case GL_STREAM_COPY: return "stream_copy";
case GL_STATIC_DRAW: return "static_draw";
case GL_STATIC_READ: return "static_read";
case GL_STATIC_COPY: return ... | addl $0xffff7720, %edi # imm = 0xFFFF7720
cmpl $0xa, %edi
ja 0x887229
movl %edi, %eax
leaq 0x3cf864(%rip), %rcx # 0xc56a88
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /kaydenl[P]VK-GL-CTS/modules/glshared/glsBufferTestUtil.cpp |
deqp::gls::BufferTestUtil::BufferWriter::BufferWriter(glu::RenderContext&, tcu::TestLog&, deqp::gls::BufferTestUtil::WriteType) | BufferWriter::BufferWriter (glu::RenderContext& renderCtx, tcu::TestLog& log, WriteType writeType)
: m_writer(DE_NULL)
{
switch (writeType)
{
case WRITE_BUFFER_SUB_DATA: m_writer = new BufferSubDataWriter (renderCtx, log); break;
case WRITE_BUFFER_WRITE_MAP: m_writer = new BufferWriteMapWriter (renderCtx, log);... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, (%rdi)
cmpl $0x1, %ecx
je 0x887661
testl %ecx, %ecx
jne 0x8876ab
movl $0x28, %edi
callq 0x325210
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq %r14, %rdi
addq $0x8, %rdi
movq %rax... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBufferTestUtil.cpp |
deqp::gls::BufferTestUtil::VertexArrayVerifier::~VertexArrayVerifier() | VertexArrayVerifier::~VertexArrayVerifier (void)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
if (m_vao) gl.deleteVertexArrays(1, &m_vao);
if (m_positionBuf) gl.deleteBuffers(1, &m_positionBuf);
if (m_indexBuf) gl.deleteBuffers(1, &m_indexBuf);
delete m_program;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3ce870(%rip), %rax # 0xc56858
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
cmpl $0x0, 0x40(%rbx)
je 0x88800e
leaq 0x40(%rbx), %rsi
movl $0x1, %edi
callq *0x490(%r14)
cmpl $0x0, 0x44(%rbx)
je 0x888024
leaq 0x44(%rbx... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBufferTestUtil.cpp |
deqp::gls::BufferTestUtil::IndexArrayVerifier::~IndexArrayVerifier() | IndexArrayVerifier::~IndexArrayVerifier (void)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
if (m_vao) gl.deleteVertexArrays(1, &m_vao);
if (m_positionBuf) gl.deleteBuffers(1, &m_positionBuf);
if (m_colorBuf) gl.deleteBuffers(1, &m_colorBuf);
delete m_program;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3cd344(%rip), %rax # 0xc56898
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
cmpl $0x0, 0x40(%rbx)
je 0x88957a
leaq 0x40(%rbx), %rsi
movl $0x1, %edi
callq *0x490(%r14)
cmpl $0x0, 0x44(%rbx)
je 0x889590
leaq 0x44(%rbx... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBufferTestUtil.cpp |
deqp::gls::(anonymous namespace)::logProgram(tcu::TestLog&, glw::Functions const&, unsigned int) | void logProgram (TestLog& log, const glw::Functions& gl, deUint32 program)
{
const bool programLinkOk = getProgramLinkStatus(gl, program);
const string programInfoLog = getProgramInfoLog(gl, program);
tcu::ScopedLogSection linkInfo (log, "Program Link Info", "Program Link Info");
{
tcu::ScopedLogSection in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movl %edx, %edi
movl $0x8b82, %esi # imm = 0x8B82
movq %r15, %rdx
callq *0x9d8(%r14)
callq *0x800(%r14)
leaq 0x1fc740(%rip), %rsi ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsAttributeLocationTests.cpp |
deqp::gls::(anonymous namespace)::generateTestName[abi:cxx11](deqp::gls::AttributeLocationTestUtil::AttribType const&, int) | string generateTestName (const AttribType& type, int arraySize)
{
return type.getName() + (arraySize != Attribute::NOT_ARRAY ? "_array_" + de::toString(arraySize) : "");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
setne %r12b
je 0x88f581
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x325e00
movq %r15, %rdi
movl %ebp, %esi
callq 0x325530
leaq 0x50(%rsp), %rsi
leaq 0x28(%... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsAttributeLocationTests.cpp |
deqp::gls::BindAliasingAttributeTest::iterate() | tcu::TestCase::IterateResult BindAliasingAttributeTest::iterate (void)
{
const vector<Bind> noBindings;
vector<Attribute> attributes;
vector<Bind> bindings;
attributes.push_back(Attribute(m_type, "a_0", Attribute::LOC_UNDEF, Cond("A", true), m_arraySize));
attributes.push_back(Attribute(AttribType("vec4", 1, GL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x170(%rsp)
xorl %eax, %eax
movq %rax, 0x180(%rsp)
movq %rax, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movq %rax, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
leaq 0x58(%rsp), ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsAttributeLocationTests.cpp |
deqp::gls::BindMaxAliasingAttributeTest::iterate() | tcu::TestCase::IterateResult BindMaxAliasingAttributeTest::iterate (void)
{
const vector<Bind> noBindings;
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx);
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);
vector<Attribute> attributes;
vector<Bind> bin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x140(%rsp)
movq $0x0, 0x150(%rsp)
movq 0x70(%rdi), %rdi
callq 0x890121
movq %rax, 0x70(%rsp)
movl 0xa0(%rbx), %eax
cmpl $-0x1, %eax
movl $0x1, %ecx
cmovnel %eax,... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsAttributeLocationTests.cpp |
deqp::gls::BindHoleAttributeTest::iterate() | deInt32 getMaxAttributeLocations (glu::RenderContext& renderCtx)
{
const glw::Functions& gl = renderCtx.getFunctions();
deInt32 maxAttribs;
gl.getIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttribs);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");
return maxAttribs;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
xorps %xmm0, %xmm0
movaps %xmm0, 0x130(%rsp)
movq $0x0, 0x140(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x70(%rdi), %rdi
callq 0x890121
movl %eax, 0x24(%rsp)
leaq 0x160(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x180ae0(%r... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsAttributeLocationTests.cpp |
deqp::gls::BindInactiveAliasingAttributeTest::iterate() | tcu::TestCase::IterateResult BindInactiveAliasingAttributeTest::iterate (void)
{
const vector<Bind> noBindings;
const deInt32 maxAttributes = getMaxAttributeLocations(m_renderCtx);
const int arrayElementCount = (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);
vector<Attribute> attributes;
vector<Bind>... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x140(%rsp)
movq $0x0, 0x150(%rsp)
movq 0x70(%rdi), %rdi
callq 0x890121
movq %rax, 0x50(%rsp)
movl 0xa0(%rbx), %eax
cmpl $-0x1, %eax
movl $0x1, %ecx
cmovnel %eax,... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsAttributeLocationTests.cpp |
deqp::gls::MixedAttributeTest::MixedAttributeTest(tcu::TestContext&, glu::RenderContext&, deqp::gls::AttributeLocationTestUtil::AttribType const&, int) | MixedAttributeTest::MixedAttributeTest (tcu::TestContext& testCtx,
glu::RenderContext& renderCtx,
const AttribType& type,
int arraySize)
: TestCase (testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
, m_renderCtx (renderCtx)
, m_type (t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %rcx, %rsi
movl %r8d, %edx
callq 0x88f4d7
movq (%r13), %r13
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
c... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsAttributeLocationTests.cpp |
rsg::AssignOp::~AssignOp() | AssignOp::~AssignOp (void)
{
delete m_lvalueExpr;
delete m_rvalueExpr;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x2d7de7(%rip), %rax # 0xc597d0
movq %rax, (%rdi)
movq 0xa0(%rdi), %rdi
testq %rdi, %rdi
je 0x9819fe
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x981a10
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x981a2b
movq 0x98(%r... | /kaydenl[P]VK-GL-CTS/framework/randomshaders/rsgExpression.cpp |
rsg::AssignOp::createNextChild(rsg::GeneratorState&) | Expression* AssignOp::createNextChild (GeneratorState& state)
{
if (m_lvalueExpr == DE_NULL)
{
// Construct lvalue
// \todo [2011-03-14 pyry] Proper l-value generation:
// - pure L-value part is generated first
// - variable valuerange is made unbound
// - R-value is generated
// - R-values in L-value... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0xa0(%rdi)
je 0x981bac
cmpq $0x0, 0xa8(%rbx)
je 0x981c1d
xorl %eax, %eax
jmp 0x981c8c
movq 0x58(%rbx), %rax
movq 0x70(%rbx), %rcx
xorl %edx, %edx
cmpq 0x60(%rbx), %rax
cmoveq %rdx, %rax
cmpq 0x78(%rbx), %rcx
cmoveq %rdx, %rcx
leaq 0x8(%rb... | /kaydenl[P]VK-GL-CTS/framework/randomshaders/rsgExpression.cpp |
rsg::AssignOp::evaluate(rsg::ExecutionContext&) | void AssignOp::evaluate (ExecutionContext& evalCtx)
{
// Evaluate l-value
m_lvalueExpr->evaluate(evalCtx);
// Evaluate value
m_rvalueExpr->evaluate(evalCtx);
m_value.setStorage(m_valueRange.getType());
m_value.getValue(m_valueRange.getType()) = m_rvalueExpr->getValue().value();
// Assign
assignMasked(m_lvalue... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa0(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0xa8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
leaq 0x88(%r14), %r12
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x97dc5e
shll $0x6, %eax
movslq %eax... | /kaydenl[P]VK-GL-CTS/framework/randomshaders/rsgExpression.cpp |
rsg::(anonymous namespace)::allocateNewVariable(rsg::GeneratorState&, rsg::ConstValueRangeAccess) | Variable* allocateNewVariable (GeneratorState& state, ConstValueRangeAccess valueRange)
{
Variable* variable = state.getVariableManager().allocate(valueRange.getType());
// Update value range
state.getVariableManager().setValue(variable, valueRange);
// Random storage \todo [pyry] Check that scalar count in unifo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq 0x60(%rsp), %r12
movq %r12, %rsi
callq 0x97bfce
movq %rax, %rbx
movq 0x28(%r14), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rsi
callq 0x97c2fa
movq 0x70... | /kaydenl[P]VK-GL-CTS/framework/randomshaders/rsgExpression.cpp |
rsg::VariableRead::getWeight(rsg::GeneratorState const&, rsg::ConstValueRangeAccess) | float VariableRead::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
{
if (valueRange.getType().isVoid())
{
if (state.getVariableManager().hasEntry(IsReadableEntry(state.getExpressionFlags())) ||
state.getVariableManager().getNumAllocatedScalars() < state.getShaderParameters().maxCombine... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x70(%rsp), %rsi
cmpl $0x0, (%rsi)
je 0x982a27
movq %rbx, %rdi
callq 0x9819a9
testb %al, %al
jne 0x982a1d
leaq 0x70(%rsp), %rax
movq 0x28(%rbx), %r14
movq 0x48(%rbx), %rcx
movl -0x4(%rcx), %ecx
movq 0x10(%rax), %rdx
movq %rdx, 0x40(%rsp)
... | /kaydenl[P]VK-GL-CTS/framework/randomshaders/rsgExpression.cpp |
rsg::VariableWrite::VariableWrite(rsg::GeneratorState&, rsg::ConstValueRangeAccess) | VariableWrite::VariableWrite (GeneratorState& state, ConstValueRangeAccess valueRange)
{
DE_ASSERT(!valueRange.getType().isVoid());
// Find variable with range that is superset of given range
IsWritableSupersetEntry::Iterator first = state.getVariableManager().getBegin(IsWritableSupersetEntry(valueRange));
IsWrita... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %r12
leaq 0x150(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
leaq 0x2d7132(%rip), %rax # 0xc59c00
movq %rax, (%rdi)
movq %rsi, 0x18(%rsp)
movq 0x28(%rsi), %r14
movq ... | /kaydenl[P]VK-GL-CTS/framework/randomshaders/rsgExpression.cpp |
rsg::ParenOp::tokenize(rsg::GeneratorState&, rsg::TokenStream&) const | void ParenOp::tokenize (GeneratorState& state, TokenStream& str) const
{
str << Token::LEFT_PAREN;
m_child->tokenize(state, str);
str << Token::RIGHT_PAREN;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq 0x18(%rdx), %rsi
subq (%rdx), %rax
sarq $0x4, %rax
cmpq %rsi, %rax
jne 0x983132
addq $0x40, %rsi
movq %rbx, %rdi
callq 0x974778
movq 0x18(%rbx), %rdi
shlq $0x4, %r... | /kaydenl[P]VK-GL-CTS/framework/randomshaders/rsgExpression.cpp |
rsg::SwizzleOp::createNextChild(rsg::GeneratorState&) | Expression* SwizzleOp::createNextChild (GeneratorState& state)
{
if (m_child)
return DE_NULL;
// Compute input value range.
VariableType inVarType = VariableType(m_outValueRange.getType().getBaseType(), m_numInputElements);
ValueRange inValueRange = ValueRange(inVarType);
// Initialize all inputs to -inf..in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
cmpq $0x0, 0x90(%rdi)
je 0x9834a7
xorl %r15d, %r15d
jmp 0x9837d7
movq %rsi, %rbx
movq %rdi, %rbp
movl 0x8(%rdi), %eax
movl 0x88(%rdi), %ecx
leaq 0x140(%rsp), %rdx
movl %eax, -0x18(%rdx)
movl $0x0, -0x14(%rdx)
mo... | /kaydenl[P]VK-GL-CTS/framework/randomshaders/rsgExpression.cpp |
rsg::TexLookup::createNextChild(rsg::GeneratorState&) | Expression* TexLookup::createNextChild (GeneratorState& state)
{
bool hasLodBias = m_type == TYPE_TEXTURE2D_LOD ||
m_type == TYPE_TEXTURE2D_PROJ_LOD ||
m_type == TYPE_TEXTURECUBE_LOD;
if (hasLodBias && !m_lodBiasExpr)
{
ValueRange lodRange(VariableType(VariableType::TYPE_FLOAT, 1));
setInfinite... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %rbx
movq %rdi, %r13
movl 0x8(%rdi), %eax
cmpl $0x5, %eax
ja 0x98408a
movl $0x2a, %ecx
btl %eax, %ecx
jae 0x98408a
cmpq $0x0, 0x20(%r13)
je 0x98409d
cmpq $0x0, 0x18(%r13)
je 0x9841d9
xorl %r14d, %r14d... | /kaydenl[P]VK-GL-CTS/framework/randomshaders/rsgExpression.cpp |
tcu::intThresholdCompare(tcu::TestLog&, char const*, char const*, tcu::ConstPixelBufferAccess const&, tcu::ConstPixelBufferAccess const&, tcu::Vector<unsigned int, 4> const&, tcu::CompareLogMode) | bool intThresholdCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const UVec4& threshold, CompareLogMode logMode)
{
int width = reference.getWidth();
int height = reference.getHeight();
int dept... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4b8, %rsp # imm = 0x4B8
movq %r9, %r13
movq %r8, %r12
movq %rdx, %rbp
movq %rsi, 0xe0(%rsp)
movq %rdi, %r15
movl 0x8(%rcx), %ebx
movl 0xc(%rcx), %r9d
movq %rcx, 0x28(%rsp)
movl 0x10(%rcx), %r8d
movabsq $0x300000007, %rax # imm = 0... | /kaydenl[P]VK-GL-CTS/framework/common/tcuImageCompare.cpp |
tcu::intThresholdPositionDeviationCompare(tcu::TestLog&, char const*, char const*, tcu::ConstPixelBufferAccess const&, tcu::ConstPixelBufferAccess const&, tcu::Vector<unsigned int, 4> const&, tcu::Vector<int, 3> const&, bool, tcu::CompareLogMode) | bool intThresholdPositionDeviationCompare (TestLog& log, const char* imageSetName, const char* imageSetDesc, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const UVec4& threshold, const tcu::IVec3& maxPositionDeviation, bool acceptOutOfBoundsAsAnyValue, CompareLogMode logMode)
{
const i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp # imm = 0x478
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, 0x78(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdi, %r14
movl 0x8(%rcx), %edx
movl 0xc(%rcx), %ecx
movl 0x10(%r12), %r8d
movabsq $0x300000007, %rax # imm = 0... | /kaydenl[P]VK-GL-CTS/framework/common/tcuImageCompare.cpp |
tcu::(anonymous namespace)::findNumPositionDeviationFailingPixels(tcu::PixelBufferAccess const&, tcu::ConstPixelBufferAccess const&, tcu::ConstPixelBufferAccess const&, tcu::Vector<unsigned int, 4> const&, tcu::Vector<int, 3> const&, bool) | static int findNumPositionDeviationFailingPixels (const PixelBufferAccess& errorMask, const ConstPixelBufferAccess& reference, const ConstPixelBufferAccess& result, const UVec4& threshold, const tcu::IVec3& maxPositionDeviation, bool acceptOutOfBoundsAsAnyValue)
{
const tcu::IVec4 okColor (0, 255, 0, 255);
const t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rdi, 0x68(%rsp)
movaps 0x9de4c(%rip), %xmm0 # 0xa41fa0
movups %xmm0, 0xc8(%rsp)
movaps 0x9de2d(%rip), %xmm0 # 0xa41f90
movups %xmm0, 0xb8(%rsp)
movq %rsi, 0x60(%rsp)
movl 0x8(%rsi), %ebx
mo... | /kaydenl[P]VK-GL-CTS/framework/common/tcuImageCompare.cpp |
tcu::getPositionOfIEEEFloatWithoutDenormals(float) | static deInt32 getPositionOfIEEEFloatWithoutDenormals (float x)
{
DE_ASSERT(!deIsNaN(x)); // not sane
if (x == 0.0f)
return 0;
else if (x < 0.0f)
return -getPositionOfIEEEFloatWithoutDenormals(-x);
else
{
DE_ASSERT(x > 0.0f);
const tcu::Float32 f(x);
if (f.isDenorm())
{
// Denorms are flushed to ... | xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x9a5f64
jp 0x9a5f64
retq
ucomiss %xmm0, %xmm1
jbe 0x9a5f7d
pushq %rax
xorps 0x5af5f(%rip), %xmm0 # 0xa00ed0
callq 0x9a5f57
negl %eax
addq $0x8, %rsp
retq
movd %xmm0, %ecx
leal -0x7fffff(%rcx), %edx
xorl %eax, %eax
testl $0x7fffff, %ecx # imm = 0x7F... | /kaydenl[P]VK-GL-CTS/framework/common/tcuImageCompare.cpp |
tcu::applyMonotone(tcu::Interval (&)(double, double), tcu::Interval const&, tcu::Interval const&) | Interval applyMonotone (DoubleIntervalFunc2& func, const Interval& arg0, const Interval& arg1)
{
double lo0 = arg0.lo(), hi0 = arg0.hi(), lo1 = arg1.lo(), hi1 = arg1.hi();
return Interval(Interval(func(lo0, lo1), func(lo0, hi1)),
Interval(func(hi0, lo1), func(hi0, hi1)));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x8(%rdx), %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rcx), %xmm1
movsd %xmm1, 0x28(%rsp)
movsd 0x10(%rcx), %xmm0
movsd %xmm0, (%rsp)
leaq 0x88(%rsp), %r15
movq %r15... | /kaydenl[P]VK-GL-CTS/framework/common/tcuInterval.cpp |
tcu::RGBA::toVec() const | int getAlpha (void) const { return (int)((m_value >> (deUint32)ALPHA_SHIFT) & 0xFFu); } | movl (%rsi), %ecx
movl $0xff, %edx
movl %ecx, %eax
andl %edx, %eax
cvtsi2ss %eax, %xmm0
movq %rdi, %rax
movl %ecx, %esi
shrl $0x8, %esi
andl %edx, %esi
cvtsi2ss %esi, %xmm1
movss 0x598d1(%rip), %xmm2 # 0xa02500
divss %xmm2, %xmm0
movl %ecx, %esi
shrl $0x10, %esi
andl %edx, %esi
cvtsi2ss %esi, %xmm3
shrl $0x18, %ecx
... | /kaydenl[P]VK-GL-CTS/framework/common/tcuRGBA.hpp |
tcu::FileResource::FileResource(char const*) | FileResource::FileResource (const char* filename)
: Resource(std::string(filename))
{
m_file = fopen(filename, "rb");
if (!m_file)
throw ResourceError("Failed to open file", filename, __FILE__, __LINE__);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x333da2
leaq 0x2b2a59(%rip), %r13 # 0xc5b9a8
movq %r13, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %r12
movq %r12, 0x8(%rbx)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp... | /kaydenl[P]VK-GL-CTS/framework/common/tcuResource.cpp |
tcu::ResourcePrefix::getResource(char const*) const | Resource* ResourcePrefix::getResource (const char* name) const
{
return m_archive.getResource((m_prefix + name).c_str());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq 0x8(%rdi), %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x334442
movq %r15, %rdi
movq %r14, %rsi
callq 0x3259c0
movq 0x8(%rsp), %r... | /kaydenl[P]VK-GL-CTS/framework/common/tcuResource.cpp |
tcu::ResourcePrefix::~ResourcePrefix() | virtual ~ResourcePrefix (void) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x2b26ab(%rip), %rax # 0xc5b918
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x9a9288
movq (%rax), %rsi
incq %rsi
callq 0x3251a0
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x3251a0
| /kaydenl[P]VK-GL-CTS/framework/common/tcuResource.hpp |
tcu::TextureCube::operator=(tcu::TextureCube const&) | TextureCube& TextureCube::operator= (const TextureCube& other)
{
if (this == &other)
return *this;
const int numLevels = computeMipPyramidLevels(other.m_size);
const ConstPixelBufferAccess* levels[CUBEFACE_LAST];
for (int face = 0; face < CUBEFACE_LAST; face++)
{
m_data[face].resize(numLevels);
m_acc... | movq %rdi, %rcx
cmpq %rsi, %rdi
je 0x9b74cd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r13
movl 0x8(%rsi), %ebp
movl $0x20, %r15d
movl $0x20, %eax
testl %ebp, %ebp
je 0x9b7328
bsrl %ebp, %eax
xorl $0x1f, %eax
subl %eax, %r15d
movq %rcx, 0x8(%rsp)
leaq 0xa0(%rcx), %r12... | /kaydenl[P]VK-GL-CTS/framework/common/tcuTexture.cpp |
tcu::Texture2DArray::allocLevel(int) | void Texture2DArray::allocLevel (int levelNdx)
{
DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels()));
const int width = getMipPyramidLevelSize(m_width, levelNdx);
const int height = getMipPyramidLevelSize(m_height, levelNdx);
TextureLevelPyramid::allocLevel(levelNdx, width, height, m_numLayers);
} | movl %esi, %ecx
movl 0x38(%rdi), %edx
movl 0x3c(%rdi), %eax
sarl %cl, %edx
cmpl $0x2, %edx
movl $0x1, %esi
cmovll %esi, %edx
sarl %cl, %eax
cmpl $0x2, %eax
cmovll %esi, %eax
movl 0x40(%rdi), %r8d
movl %ecx, %esi
movl %eax, %ecx
jmp 0x9b5b64
| /kaydenl[P]VK-GL-CTS/framework/common/tcuTexture.cpp |
tcu::Texture3D::operator=(tcu::Texture3D const&) | Texture3D& Texture3D::operator= (const Texture3D& other)
{
if (this == &other)
return *this;
TextureLevelPyramid::operator=(other);
m_width = other.m_width;
m_height = other.m_height;
m_depth = other.m_depth;
m_view = Texture3DView(getNumLevels(), getLevels());
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x9b7e00
movq %rsi, %r14
movq %rbx, %rdi
callq 0x9b5958
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movl 0x3c(%r14), %eax
movl %eax, 0x3c(%rbx)
movl 0x40(%r14), %eax
movl %eax, 0x40(%rbx)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
subq %rax, %rcx
shrq... | /kaydenl[P]VK-GL-CTS/framework/common/tcuTexture.cpp |
van_kampen::Graph::mergeNodes(int, int, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&) | void Graph::mergeNodes(nodeId_t alive, nodeId_t dead, const std::unordered_set<nodeId_t> &untouchable)
{
for (Transition &edgeFromDead : node(dead).transitions())
{
if (untouchable.count(edgeFromDead.to))
{
continue;
}
node(alive).addTransition(edgeFromDead.to, edgeFr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
movl %edx, %esi
callq 0x4c996
movq 0x20(%rax), %r15
movq 0x30(%rax), %r12
movq 0x38(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x40(%rax), %r13
cmpq %r13, %r15
je 0x4cd93
m... | /Glebanister[P]van_kampen_diagramm/src/Graph.cpp |
cxxopts::values::abstract_value<unsigned long>::implicit_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::shared_ptr<Value>
implicit_value(const std::string& value) override
{
m_implicit = true;
m_implicit_value = value;
return shared_from_this();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x31(%rsi)
leaq 0x58(%rsi), %rdi
movq %rdx, %rsi
callq 0x3e200
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5970a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Glebanister[P]van_kampen_diagramm/extern/cxxopts/include/cxxopts.hpp |
cxxopts::values::abstract_value<unsigned long>::abstract_value(cxxopts::values::abstract_value<unsigned long> const&) | abstract_value(const abstract_value& rhs)
{
if (rhs.m_result)
{
m_result = std::make_shared<T>();
m_store = m_result.get();
}
else
{
m_store = rhs.m_store;
}
m_default = rhs.m_default;
m_implicit = rhs.m_implicit;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x1b5e5(%rip), %rax # 0x77ae8
movq %rax, (%rdi)
movups %xmm0, 0x18(%rdi)
andw $0x0, 0x30(%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
lea... | /Glebanister[P]van_kampen_diagramm/extern/cxxopts/include/cxxopts.hpp |
van_kampen::LargeFirstAlgorithm::generate(std::vector<std::vector<van_kampen::GroupElement, std::allocator<van_kampen::GroupElement>>, std::allocator<std::vector<van_kampen::GroupElement, std::allocator<van_kampen::GroupElement>>>> const&) | void LargeFirstAlgorithm::generate(const std::vector<std::vector<GroupElement>> &words)
{
std::size_t totalIterations = words.size();
if (cellsLimit)
{
totalIterations = std::min(totalIterations, cellsLimit);
}
ProcessLogger logger(totalIterations, std::clog, "Relations used", quiet);
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %r13
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x18
popq %rbx
cqto
idivq %rbx
movq 0x18(%rdi), %rcx
cmpq %rax, %rcx
movq %rax, %r15
cmovbq %rcx, %r15
testq %rcx, %rcx
cmoveq %rax, ... | /Glebanister[P]van_kampen_diagramm/src/LargeFirstAlgorithm.cpp |
van_kampen::MergingAlgorithm::MergingAlgorithm() | MergingAlgorithm::MergingAlgorithm()
: result_(graph_) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x5ce98
leaq 0x1a340(%rip), %rax # 0x77cd8
movq %rax, (%rbx)
andq $0x0, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r14
leaq 0x8(%rbx), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x4f9ce
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e9ae
leaq... | /Glebanister[P]van_kampen_diagramm/src/MergingAlgorithm.cpp |
generate_anchors(int, ncnn::Mat const&, ncnn::Mat const&) | static ncnn::Mat generate_anchors(int base_size, const ncnn::Mat& ratios, const ncnn::Mat& scales)
{
int num_ratio = ratios.w;
int num_scale = scales.w;
ncnn::Mat anchors;
anchors.create(4, num_ratio * num_scale);
const float cx = 0;
const float cy = 0;
for (int i = 0; i < num_ratio; i++)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rdx, 0x10(%rsp)
movl 0x2c(%rdx), %r13d
movq %rcx, 0x18(%rsp)
movslq 0x2c(%rcx), %r12
andq $0x0, 0x40(%rdi)
movl %esi, %r14d
movl %r12d, %edx
imull %r13d, %edx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x... | /csukuangfj[P]ncnn/examples/scrfd_crowdhuman.cpp |
ncnn::Mat::create(int, int, int, unsigned long, int, ncnn::Allocator*) | void Mat::create(int _w, int _h, int _c, size_t _elemsize, int _elempack, Allocator* _allocator)
{
if (dims == 3 && w == _w && h == _h && c == _c && elemsize == _elemsize && elempack == _elempack && allocator == _allocator)
return;
release();
elemsize = _elemsize;
elempack = _elempack;
all... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
movq 0x40(%rsp), %rdi
cmpl $0x3, 0x28(%rbx)
jne 0x62940
cmpl %r13d, 0x2c(%rbx)
jne 0x62940
cmpl %r12d, 0x30(%rbx)
jne 0x62940
cmpl %ebp, 0x38(%rb... | /csukuangfj[P]ncnn/src/mat.cpp |
ncnn::Mat::reshape(int, int, ncnn::Allocator*) const | Mat Mat::reshape(int _w, int _h, Allocator* _allocator) const
{
if (w * h * d * c != _w * _h)
return Mat();
if (dims >= 3 && cstep != (size_t)w * h * d)
{
Mat m;
m.create(_w, _h, elemsize, elempack, _allocator);
// flatten
for (int i = 0; i < c; i++)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r9
movq %rsi, %r14
movq %rdi, %rbx
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %esi
movl %esi, %r10d
imull %eax, %r10d
movl 0x34(%r14), %edi
movl 0x38(%r14), %r8d
movl %edi, %r11d
imull %r8d, %r11d
imull %r10d, %r11d
movl %ecx, %r10d
imull %edx, %r10d
cmpl %r... | /csukuangfj[P]ncnn/src/mat.cpp |
ncnn::Mat::reshape(int, int, int, ncnn::Allocator*) const | Mat Mat::reshape(int _w, int _h, int _c, Allocator* _allocator) const
{
if (w * h * d * c != _w * _h * _c)
return Mat();
if (dims < 3)
{
if ((size_t)_w * _h != alignSize((size_t)_w * _h * elemsize, 16) / elemsize)
{
Mat m;
m.create(_w, _h, _c, elemsize, elemp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r13
movl %edx, %r12d
movq %rdi, %rbx
movl 0x2c(%rsi), %edi
movl 0x30(%rsi), %r9d
movl %r9d, %eax
imull %edi, %eax
movl 0x34(%rsi), %r10d
movl 0x38(%rsi), %r11d
movl %r10d, %edx
imull %r11d, %edx
imull %eax, %edx
movl %ecx, %ea... | /csukuangfj[P]ncnn/src/mat.cpp |
ncnn::Blob::~Blob() | class NCNN_EXPORT Blob
{
public:
// empty
Blob();
public:
#if NCNN_STRING
// blob name
std::string name;
#endif // NCNN_STRING
// layer index which produce this blob as output
int producer;
// layer index which need this blob as input
int consumer;
// shape hint
Mat shape;
} | pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x6ff89
lock
decl (%rax)
jne 0x6ff89
movq 0x28(%rbx), %rsi
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x6ff81
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x6ff89
movq %rsi, %rdi
callq 0x5f3e0
leaq 0x28(%rbx), %rax
andq $0x0, 0x68(%rbx)
xorps %xmm0, %xmm0
m... | /csukuangfj[P]ncnn/src/blob.h |
ncnn::ParamDict::ParamDict(ncnn::ParamDict const&) | ParamDict::ParamDict(const ParamDict& rhs)
: d(new ParamDictPrivate)
{
for (int i = 0; i < NCNN_MAX_PARAM_COUNT; i++)
{
int type = rhs.d->params[i].type;
d->params[i].type = type;
if (type == 1 || type == 2 || type == 3)
{
d->params[i].i = rhs.d->params[i].i;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3ecc1e(%rip), %rax # 0x45e288
movq %rax, (%rdi)
movl $0xa00, %edi # imm = 0xA00
callq 0x5f3d0
movq %rax, %r15
movq %rax, %rdi
callq 0x72028
movq %r15, 0x8(%r14)
xorl %r15d, %r15d
xorps %xmm1, %xmm1
cmpq $0xa00, %... | /csukuangfj[P]ncnn/src/paramdict.cpp |
ncnn::vstr_is_float(char const*) | static bool vstr_is_float(const char vstr[16])
{
// look ahead for determine isfloat
for (int j = 0; j < 16; j++)
{
if (vstr[j] == '\0')
break;
if (vstr[j] == '.' || tolower(vstr[j]) == 'e')
return true;
}
return false;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x10, %r14
je 0x71d26
movzbl (%rbx,%r14), %eax
testl %eax, %eax
je 0x71d26
cmpl $0x2e, %eax
je 0x71d22
movsbl %al, %edi
callq 0x5f500
incq %r14
cmpl $0x65, %eax
jne 0x71cfe
movb $0x1, %al
jmp 0x71d28
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq ... | /csukuangfj[P]ncnn/src/paramdict.cpp |
ncnn::cpu_support_x86_fma() | int cpu_support_x86_fma()
{
try_initialize_global_cpu_info();
#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
return g_cpu_support_x86_fma;
#else
return 0;
#endif
} | pushq %rax
callq 0x72ac4
movl 0x41d187(%rip), %eax # 0x490460
popq %rcx
retq
| /csukuangfj[P]ncnn/src/cpu.cpp |
ncnn::cpu_support_x86_xop() | int cpu_support_x86_xop()
{
try_initialize_global_cpu_info();
#if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
return g_cpu_support_x86_xop;
#else
return 0;
#endif
} | pushq %rax
callq 0x72ac4
movl 0x41d17d(%rip), %eax # 0x490464
popq %rcx
retq
| /csukuangfj[P]ncnn/src/cpu.cpp |
ncnn::cpu_support_riscv_v() | int cpu_support_riscv_v()
{
try_initialize_global_cpu_info();
#if defined __ANDROID__ || defined __linux__
#if __riscv
return g_hwcaps & COMPAT_HWCAP_ISA_V;
#else
return 0;
#endif
#else
return 0;
#endif
} | pushq %rax
callq 0x72ac4
xorl %eax, %eax
popq %rcx
retq
| /csukuangfj[P]ncnn/src/cpu.cpp |
ncnn::test_prefer_winograd63(int, int, int, int) | static bool test_prefer_winograd63(int num_input, int num_output, int w, int h)
{
// winograd selection strategy (profiled on i7-7700 single thread)
int minwh = std::min(w, h);
if (num_input >= 64)
{
return false;
}
if (num_input >= 32)
{
if (num_output >= 64) return false;... | cmpl %edx, %ecx
cmovll %ecx, %edx
cmpl $0x3f, %edi
jle 0x9ba1d
xorl %eax, %eax
retq
cmpl $0x20, %edi
jl 0x9ba66
cmpl $0x3f, %esi
jg 0x9ba1a
cmpl $0x20, %esi
jl 0x9baed
movd %edx, %xmm0
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
paddd 0x35614f(%rip), %xmm0 # 0x3f1b90
pxor 0x352647(%rip), %xmm0 # 0x3ee090
... | /csukuangfj[P]ncnn/src/layer/x86/convolution_x86.cpp |
ncnn::test_prefer_winograd23(int, int, int, int) | static bool test_prefer_winograd23(int num_input, int num_output, int w, int h)
{
int minwh = std::min(w, h);
if (num_input >= 512)
{
if (num_output >= 512) return (minwh >= 3 && minwh <= 14);
if (num_output >= 256) return (minwh >= 3 && minwh <= 14);
if (num_output >= 128) return (... | cmpl %edx, %ecx
cmovll %ecx, %edx
cmpl $0x200, %edi # imm = 0x200
jl 0x9bc47
cmpl $0x200, %esi # imm = 0x200
jge 0x9bc83
cmpl $0x100, %esi # imm = 0x100
jge 0x9bc83
cmpl $0x80, %esi
jge 0x9bc83
cmpl $0x40, %esi
jge 0x9bcbe
jmp 0x9bd01
cmpl $0x100, %edi # imm = 0x100
jl 0x9bc7... | /csukuangfj[P]ncnn/src/layer/x86/convolution_x86.cpp |
ncnn::Convolution_x86::destroy_pipeline(ncnn::Option const&) | int Convolution_x86::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
if (convolution_dilation1)
{
convolution_dilation1->destroy_pipeline(opt);
delete convolution_dilation1;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x9bf50
movq (%rdi), %rax
movq %r14, %rsi
callq *0x28(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x9bf4b
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rbx)
movq 0x180(%rbx), %rdi
testq %rdi, %rdi
je 0x9bf7... | /csukuangfj[P]ncnn/src/layer/x86/convolution_x86.cpp |
virtual thunk to ncnn::Convolution_x86::destroy_pipeline(ncnn::Option const&) | int Convolution_x86::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
if (convolution_dilation1)
{
convolution_dilation1->destroy_pipeline(opt);
delete convolution_dilation1;
... | pushq %rax
movq (%rdi), %rax
addq -0x38(%rax), %rdi
callq 0x9bf20
xorl %eax, %eax
popq %rcx
retq
nop
| /csukuangfj[P]ncnn/src/layer/x86/convolution_x86.cpp |
ncnn::Convolution_x86::forward_int8_x86(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Convolution_x86::forward_int8_x86(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int elembits = bottom_blob.elembits();
Mat bottom_blob_int8 = bottom_blob;
if (elembits != 8)
{
Option opt_q = opt;
opt_q.blob_allocator = opt.workspace_allocator;
quantize_to... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6f8, %rsp # imm = 0x6F8
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, 0x20(%rsp)
movl 0x18(%rsi), %ecx
movq 0x10(%rsi), %rdi
testl %ecx, %ecx
je 0xa62eb
leal (,%rdi,8), %eax
cltd
idivl %ecx
cmpl $0x8, %eax
sete %al
jmp 0xa62ed
xorl %eax, ... | /csukuangfj[P]ncnn/src/layer/x86/convolution_x86.cpp |
ncnn::im2col_sgemm_pack8to1_int8_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void im2col_sgemm_pack8to1_int8_sse(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Option& opt)
{
#if !(__AVX512VNNI__ || __AVXVNNI__ || __AVX2__ || __XOP__)
#if NCNN_RUNTIME_CPU && NCNN_AVX512VNNI && __AVX512F__ && !__AVX512VNNI__
if (ncnn::cpu_support_x86_avx512_vnni())
{
im2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x732db
testl %eax, %eax
je 0xb3945
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_pack8to1_int8.h |
ncnn::im2col_sgemm_int8_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void im2col_sgemm_int8_sse(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Option& opt)
{
#if !(__AVX512VNNI__ || __AVXVNNI__ || __AVX2__ || __XOP__)
#if NCNN_RUNTIME_CPU && NCNN_AVX512VNNI && __AVX512F__ && !__AVX512VNNI__
if (ncnn::cpu_support_x86_avx512_vnni())
{
im2col_sgemm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x732db
testl %eax, %eax
je 0xb413a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_int8.h |
ncnn::convolution_im2col_sgemm_transform_kernel_pack8to1_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int) | static void convolution_im2col_sgemm_transform_kernel_pack8to1_int8_sse(const Mat& _kernel, Mat& kernel_tm, int inch, int outch, int kernel_w, int kernel_h)
{
const int maxk = kernel_w * kernel_h;
// interleave
// src = maxk-inch-outch
// dst = 8a-4b-maxk-inch/8a-outch/4b
Mat kernel = _kernel.resha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rsi
imull %r9d, %ebx
movq %rsp, %rdi
movl %ebx, %edx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x63020
pushq $0x8
popq %rcx
movl %r15d, %eax
cltd
i... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_pack8to1_int8.h |
ncnn::Convolution_x86_fma::create_pipeline(ncnn::Option const&) | int Convolution_x86_fma::create_pipeline(const Option& opt)
{
if (dynamic_weight)
return 0;
activation = create_activation_layer(activation_type, activation_params, opt);
nT = opt.num_threads;
#if NCNN_INT8
if (opt.use_int8_inference && weight_data.elemsize == (size_t)1u)
{
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq (%rdi), %rax
movq -0x18(%rax), %rbx
cmpl $0x0, 0x158(%rdi,%rbx)
je 0xe34e0
xorl %eax, %eax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_fma.cpp |
ncnn::conv3x3s1_winograd43_transform_kernel(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&) | static void conv3x3s1_winograd43_transform_kernel(const Mat& kernel, Mat& AT, int inch, int outch, const Option& opt)
{
const int M = outch;
const int K = inch;
const int B = 36;
int TILE_M, TILE_N, TILE_K;
get_optimal_tile_mnk(M, 0, K, TILE_M, TILE_N, TILE_K, opt.num_threads);
const int nn_M ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %r8, %r13
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, 0x18(%rsp)
movq %rdi, %r12
movl 0x4(%r8), %eax
movl %eax, (%rsp)
leaq 0xac(%rsp), %rbx
leaq 0xa8(%rsp), %r8
leaq 0xa4(%rsp), %rbp
movl %ecx, %edi
xorl ... | /csukuangfj[P]ncnn/src/layer/x86/convolution_3x3_winograd.h |
ncnn::conv3x3s1_winograd23_transform_kernel(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&) | static void conv3x3s1_winograd23_transform_kernel(const Mat& kernel, Mat& AT, int inch, int outch, const Option& opt)
{
const int M = outch;
const int K = inch;
const int B = 16;
int TILE_M, TILE_N, TILE_K;
get_optimal_tile_mnk(M, 0, K, TILE_M, TILE_N, TILE_K, opt.num_threads);
const int nn_M ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r8, %r13
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, 0x28(%rsp)
movq %rdi, %r12
movl 0x4(%r8), %eax
movl %eax, (%rsp)
leaq 0xbc(%rsp), %rbx
leaq 0xb8(%rsp), %r8
leaq 0xb4(%rsp), %rbp
movl %ecx, %edi
xorl ... | /csukuangfj[P]ncnn/src/layer/x86/convolution_3x3_winograd.h |
ncnn::test_prefer_winograd63(int, int, int, int) | static bool test_prefer_winograd63(int num_input, int num_output, int w, int h)
{
// winograd selection strategy (profiled on i7-7700 single thread)
int minwh = std::min(w, h);
if (num_input >= 64)
{
return false;
}
if (num_input >= 32)
{
if (num_output >= 64) return false;... | cmpl %edx, %ecx
cmovll %ecx, %edx
cmpl $0x3f, %edi
jle 0xe8733
xorl %eax, %eax
retq
cmpl $0x20, %edi
jl 0xe8778
cmpl $0x3f, %esi
jg 0xe8730
cmpl $0x20, %esi
jl 0xe87f7
vmovd %edx, %xmm0
vpshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
vpaddd 0x309439(%rip), %xmm0, %xmm0 # 0x3f1b90
vpminud 0x30a150(%rip), %xmm0, %... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_fma.cpp |
ncnn::test_prefer_winograd23(int, int, int, int) | static bool test_prefer_winograd23(int num_input, int num_output, int w, int h)
{
int minwh = std::min(w, h);
if (num_input >= 512)
{
if (num_output >= 512) return (minwh >= 3 && minwh <= 14);
if (num_output >= 256) return (minwh >= 3 && minwh <= 14);
if (num_output >= 128) return (... | cmpl %edx, %ecx
cmovll %ecx, %edx
cmpl $0x200, %edi # imm = 0x200
jl 0xe894d
cmpl $0x200, %esi # imm = 0x200
jge 0xe8989
cmpl $0x100, %esi # imm = 0x100
jge 0xe8989
cmpl $0x80, %esi
jge 0xe8989
cmpl $0x40, %esi
jge 0xe89c4
jmp 0xe8a07
cmpl $0x100, %edi # imm = 0x100
jl 0xe897... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_fma.cpp |
ncnn::Convolution_x86_fma::forward_int8_x86(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Convolution_x86_fma::forward_int8_x86(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int elembits = bottom_blob.elembits();
Mat bottom_blob_int8 = bottom_blob;
if (elembits != 8)
{
Option opt_q = opt;
opt_q.blob_allocator = opt.workspace_allocator;
quantiz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6e8, %rsp # imm = 0x6E8
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, 0x20(%rsp)
movl 0x18(%rsi), %ecx
movq 0x10(%rsi), %rdi
testl %ecx, %ecx
je 0xf8f2b
leal (,%rdi,8), %eax
cltd
idivl %ecx
cmpl $0x8, %eax
sete %al
jmp 0xf8f2d
xorl %eax, ... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_fma.cpp |
ncnn::Convolution_x86_fma::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Convolution_x86_fma::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& _weight_data = bottom_blobs[1];
Mat& top_blob = top_blobs[0];
const int _kernel_w = _weight_data.w;
const int _kernel_h... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %rbp
movq %rdi, %r13
movq (%rsi), %r14
leaq 0x48(%r14), %rdi
movq (%rdx), %rax
movq %rax, 0xb8(%rsp)
movl 0x60(%r14), %ebx
movl 0x74(%r14), %eax
movl %eax, 0x1c(%rsp)
movl 0x78(%r14), %eax
movl %eax, ... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_fma.cpp |
virtual thunk to ncnn::Convolution_x86_fma::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Convolution_x86_fma::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& _weight_data = bottom_blobs[1];
Mat& top_blob = top_blobs[0];
const int _kernel_w = _weight_data.w;
const int _kernel_h... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x100126
| /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_fma.cpp |
ncnn::convolution_im2col_sgemm_transform_kernel_pack8to4_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int) | static void convolution_im2col_sgemm_transform_kernel_pack8to4_int8_sse(const Mat& _kernel, Mat& kernel_tm, int inch, int outch, int kernel_w, int kernel_h)
{
const int maxk = kernel_w * kernel_h;
// interleave
// src = maxk-inch-outch
// dst = 8a-4b-maxk-inch/8a-outch/4b
Mat kernel = _kernel.resha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rsi
imull %r9d, %ebx
xorl %r12d, %r12d
movq %rsp, %rdi
movl %ebx, %edx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x63020
movl %ebx, %esi
shll $0x5,... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_pack8to4_int8.h |
ncnn::convolution_transform_kernel_packed_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int, int, int) | static void convolution_transform_kernel_packed_int8_sse(const Mat& weight_data, Mat& weight_data_tm, int num_input, int num_output, int kernel_w, int kernel_h, int elempack, int out_elempack)
{
const int maxk = kernel_w * kernel_h;
// src = kw-kh-inch-outch
// dst = pa-pb-kw-kh-inch/pa-outch/pb
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, %ebx
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rsi
movl 0xb0(%rsp), %ebp
imull %r9d, %ebx
xorl %r15d, %r15d
leaq 0x30(%rsp), %rdi
movl %ebx, %edx
movl %r13d, %ecx
movl %r12d, %r8d
xorl %r9d, %r9d
callq 0x63... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_fma.cpp |
ncnn::convolution_im2col_sgemm_transform_kernel_pack8to1_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int) | static void convolution_im2col_sgemm_transform_kernel_pack8to1_int8_sse(const Mat& _kernel, Mat& kernel_tm, int inch, int outch, int kernel_w, int kernel_h)
{
const int maxk = kernel_w * kernel_h;
// interleave
// src = maxk-inch-outch
// dst = 8a-4b-maxk-inch/8a-outch/4b
Mat kernel = _kernel.resha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rsi
imull %r9d, %ebx
movq %rsp, %rdi
movl %ebx, %edx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x63020
pushq $0x8
popq %rcx
movl %r15d, %eax
cltd
i... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_pack8to1_int8.h |
ncnn::convolution_im2col_sgemm_transform_kernel_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int) | static void convolution_im2col_sgemm_transform_kernel_int8_sse(const Mat& _kernel, Mat& kernel_tm, int inch, int outch, int kernel_w, int kernel_h)
{
const int maxk = kernel_w * kernel_h;
#if __SSE2__
// interleave
// src = maxk-inch-outch
// dst = 4a-4b-maxk-inch/4a-outch/4b
Mat kernel = _kernel.r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rsi
imull %r9d, %ebx
movq %rsp, %rdi
movl %ebx, %edx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x63020
cmpl $0x4, %ebp
jl 0x1010a9
cmpl $0x4, %r15d... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_int8.h |
ncnn::get_optimal_tile_mnk(int, int, int, int&, int&, int&, int) | static void get_optimal_tile_mnk(int M, int N, int K, int& TILE_M, int& TILE_N, int& TILE_K, int nT)
{
// resolve optimal tile size from cache size
const size_t l2_cache_size = get_cpu_level2_cache_size();
if (nT == 0)
nT = get_physical_big_cpu_count();
// solve M
{
int tile_size =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, %r15
movl %edx, %r13d
movq %rsi, 0x10(%rsp)
movl %edi, %ebx
movl 0x60(%rsp), %ebp
callq 0x73479
movl %eax, %r12d
movslq %eax, %r14
testl %ebp, %ebp
jne 0x101710
callq 0x7345d
movl %eax... | /csukuangfj[P]ncnn/src/layer/x86/convolution_3x3_winograd.h |
ncnn::pack_A_tile(ncnn::Mat const&, ncnn::Mat&, int, int, int) | static void pack_A_tile(const Mat& A, Mat& AT, int batch, int max_ii, int max_kk)
{
const int N = max_kk * batch;
for (int b = 0; b < batch; b++)
{
float* pp = AT.row(b);
int ii = 0;
#if __SSE2__
#if __AVX__
#if __AVX512F__
for (; ii + 15 < max_ii; ii += 16)
{
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %r10d
movq %rdi, -0x68(%rsp)
movl %r8d, %eax
imull %edx, %eax
movq (%rsi), %r8
movq %r8, -0x30(%rsp)
movslq 0x2c(%rsi), %r8
imulq 0x10(%rsi), %r8
movq %r8, -0x38(%rsp)
movslq %eax, %r11
leal (%r11,%r11), %eax
movslq %eax, %r14
leal (%r11,%r11,... | /csukuangfj[P]ncnn/src/layer/x86/convolution_3x3_winograd.h |
ncnn::im2col_sgemm_pack8to4_int8_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void im2col_sgemm_pack8to4_int8_sse(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Option& opt)
{
#if !(__AVX512VNNI__ || __AVXVNNI__ || __AVX2__ || __XOP__)
#if NCNN_RUNTIME_CPU && NCNN_AVX512VNNI && __AVX512F__ && !__AVX512VNNI__
if (ncnn::cpu_support_x86_avx512_vnni())
{
im2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x732f7
testl %eax, %eax
je 0x107af0
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_pack8to4_int8.h |
ncnn::im2col_sgemm_pack8to1_int8_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void im2col_sgemm_pack8to1_int8_sse(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Option& opt)
{
#if !(__AVX512VNNI__ || __AVXVNNI__ || __AVX2__ || __XOP__)
#if NCNN_RUNTIME_CPU && NCNN_AVX512VNNI && __AVX512F__ && !__AVX512VNNI__
if (ncnn::cpu_support_x86_avx512_vnni())
{
im2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x732f7
testl %eax, %eax
je 0x1086a3
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_pack8to1_int8.h |
ncnn::im2col_sgemm_int8_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void im2col_sgemm_int8_sse(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Option& opt)
{
#if !(__AVX512VNNI__ || __AVXVNNI__ || __AVX2__ || __XOP__)
#if NCNN_RUNTIME_CPU && NCNN_AVX512VNNI && __AVX512F__ && !__AVX512VNNI__
if (ncnn::cpu_support_x86_avx512_vnni())
{
im2col_sgemm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x732f7
testl %eax, %eax
je 0x108ddb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_int8.h |
ncnn::Convolution_x86_avx::Convolution_x86_avx() | Convolution_x86_avx::Convolution_x86_avx()
{
#if __SSE2__
support_packing = true;
#endif // __SSE2__
activation = 0;
nT = 0;
convolution_dilation1 = 0;
gemm = 0;
} | movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq -0x18(%rax), %rax
movq %rcx, (%rdi,%rax)
andq $0x0, 0x178(%rdi)
andq $0x0, 0x1d0(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x18(%rdi)
vmovups %xmm0, 0x24(%rdi)
vmovups %xmm0, 0x38(%rdi)
vmovups %xmm0, 0x44(%rdi)
vxorps %xmm1, %xmm1, %xmm1
andl $0x0, 0x... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_avx.cpp |
ncnn::Convolution_x86_avx::Convolution_x86_avx() | Convolution_x86_avx::Convolution_x86_avx()
{
#if __SSE2__
support_packing = true;
#endif // __SSE2__
activation = 0;
nT = 0;
convolution_dilation1 = 0;
gemm = 0;
} | pushq %rbx
movq %rdi, %rbx
addq $0x1d8, %rdi # imm = 0x1D8
callq 0x94b00
leaq 0x377a8f(%rip), %rax # 0x481318
movq %rax, (%rbx)
leaq 0x377b0d(%rip), %rax # 0x4813a0
movq %rax, 0x1d8(%rbx)
andq $0x0, 0x178(%rbx)
andq $0x0, 0x1d0(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x18(%rbx)
vmovups %xmm0, 0... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_avx.cpp |
ncnn::Convolution_x86_avx::create_pipeline(ncnn::Option const&) | int Convolution_x86_avx::create_pipeline(const Option& opt)
{
if (dynamic_weight)
return 0;
activation = create_activation_layer(activation_type, activation_params, opt);
nT = opt.num_threads;
#if NCNN_INT8
if (opt.use_int8_inference && weight_data.elemsize == (size_t)1u)
{
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq (%rdi), %rax
movq -0x18(%rax), %rbx
cmpl $0x0, 0x158(%rdi,%rbx)
je 0x1099b0
xorl %eax, %eax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_avx.cpp |
ncnn::Convolution_x86_avx::create_pipeline_int8_x86(ncnn::Option const&) | int Convolution_x86_avx::create_pipeline_int8_x86(const Option& opt)
{
const int maxk = kernel_w * kernel_h;
const int num_input = weight_data_size / maxk / num_output;
int elempack = 1;
int out_elempack = 1;
#if __SSE2__
if (opt.use_packing_layout)
{
elempack = num_input % 8 == 0 ? 8 :... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %r12
movl 0xd4(%rdi,%r12), %r8d
movl 0xd8(%rdi,%r12), %r9d
movl %r9d, %ecx
imull %r8d, %ecx
movl 0x104(%rdi,%r12), %eax
cltd
idivl %ecx
movslq 0xd0(%rdi,%r12),... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_avx.cpp |
ncnn::conv3x3s1_winograd23_transform_kernel(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&) | static void conv3x3s1_winograd23_transform_kernel(const Mat& kernel, Mat& AT, int inch, int outch, const Option& opt)
{
const int M = outch;
const int K = inch;
const int B = 16;
int TILE_M, TILE_N, TILE_K;
get_optimal_tile_mnk(M, 0, K, TILE_M, TILE_N, TILE_K, opt.num_threads);
const int nn_M ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r8, %r13
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, 0x28(%rsp)
movq %rdi, %r12
movl 0x4(%r8), %eax
movl %eax, (%rsp)
leaq 0xbc(%rsp), %rbx
leaq 0xb8(%rsp), %r8
leaq 0xb4(%rsp), %rbp
movl %ecx, %edi
xorl ... | /csukuangfj[P]ncnn/src/layer/x86/convolution_3x3_winograd.h |
ncnn::test_prefer_winograd63(int, int, int, int) | static bool test_prefer_winograd63(int num_input, int num_output, int w, int h)
{
// winograd selection strategy (profiled on i7-7700 single thread)
int minwh = std::min(w, h);
if (num_input >= 64)
{
return false;
}
if (num_input >= 32)
{
if (num_output >= 64) return false;... | cmpl %edx, %ecx
cmovll %ecx, %edx
cmpl $0x3f, %edi
jle 0x10ec06
xorl %eax, %eax
retq
cmpl $0x20, %edi
jl 0x10ec4b
cmpl $0x3f, %esi
jg 0x10ec03
cmpl $0x20, %esi
jl 0x10ecca
vmovd %edx, %xmm0
vpshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
vpaddd 0x2e2f66(%rip), %xmm0, %xmm0 # 0x3f1b90
vpminud 0x2e3c7d(%rip), %xmm... | /csukuangfj[P]ncnn/build_O2/src/layer/x86/convolution_x86_avx.cpp |
ncnn::convolution_im2col_sgemm_transform_kernel_pack8to1_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int) | static void convolution_im2col_sgemm_transform_kernel_pack8to1_int8_sse(const Mat& _kernel, Mat& kernel_tm, int inch, int outch, int kernel_w, int kernel_h)
{
const int maxk = kernel_w * kernel_h;
// interleave
// src = maxk-inch-outch
// dst = 8a-4b-maxk-inch/8a-outch/4b
Mat kernel = _kernel.resha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rsi
imull %r9d, %ebx
movq %rsp, %rdi
movl %ebx, %edx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x63020
pushq $0x8
popq %rcx
movl %r15d, %eax
cltd
i... | /csukuangfj[P]ncnn/src/layer/x86/convolution_sgemm_pack8to1_int8.h |
ncnn::conv3x3s1_winograd43_transform_kernel_pack8to4_int8_sse_avx2(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&) | void conv3x3s1_winograd43_transform_kernel_pack8to4_int8_sse_avx2(const Mat& kernel, Mat& kernel_tm, int inch, int outch, const Option& opt)
{
conv3x3s1_winograd43_transform_kernel_pack8to4_int8_sse(kernel, kernel_tm, inch, outch, opt);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, 0x38(%rsp)
leaq 0x60(%rsp), %rdi
andq $0x0, 0x40(%rdi)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, (%rdi)
vmovdqu %xmm0, 0xc(%rdi)
vmovdqa %xmm0, 0x20(%rdi)
vmovdqu %xmm0, 0x2c(%rd... | /csukuangfj[P]ncnn/src/layer/x86/convolution_x86_avx2.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.