framework/opengl/gluShaderProgram.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Wrapper for GL program object.
 *//*--------------------------------------------------------------------*/

#include "gluShaderProgram.hpp"
#include "gluRenderContext.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "tcuTestLog.hpp"
#include "deClock.h"

#include <cstring>

using std::string;

namespace glu
{

// Shader

Shader::Shader(const RenderContext &renderCtx, ShaderType shaderType) : m_gl(renderCtx.getFunctions()), m_shader(0)
{
    m_info.type = shaderType;
    m_shader    = m_gl.createShader(getGLShaderType(shaderType));
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCreateShader()");
    TCU_CHECK(m_shader);
}

Shader::Shader(const glw::Functions &gl, ShaderType shaderType) : m_gl(gl), m_shader(0)
{
    m_info.type = shaderType;
    m_shader    = m_gl.createShader(getGLShaderType(shaderType));
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCreateShader()");
    TCU_CHECK(m_shader);
}

Shader::~Shader(void)
{
    m_gl.deleteShader(m_shader);
}

void Shader::setSources(int numSourceStrings, const char *const *sourceStrings, const int *lengths)
{
    m_gl.shaderSource(m_shader, numSourceStrings, sourceStrings, lengths);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glShaderSource()");

    m_info.source.clear();
    for (int ndx = 0; ndx < numSourceStrings; ndx++)
    {
        const size_t length = lengths && lengths[ndx] >= 0 ? lengths[ndx] : strlen(sourceStrings[ndx]);
        m_info.source += std::string(sourceStrings[ndx], length);
    }
}

void Shader::compile(void)
{
    m_info.compileOk     = false;
    m_info.compileTimeUs = 0;
    m_info.infoLog.clear();

    {
        uint64_t compileStart = deGetMicroseconds();
        m_gl.compileShader(m_shader);
        m_info.compileTimeUs = deGetMicroseconds() - compileStart;
    }

    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCompileShader()");

    // Query status
    {
        int compileStatus = 0;

        m_gl.getShaderiv(m_shader, GL_COMPILE_STATUS, &compileStatus);
        GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderiv()");

        m_info.compileOk = compileStatus != GL_FALSE;
    }

    // Query log
    {
        int infoLogLen = 0;
        int unusedLen;

        m_gl.getShaderiv(m_shader, GL_INFO_LOG_LENGTH, &infoLogLen);
        GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderiv()");

        if (infoLogLen > 0)
        {
            // The INFO_LOG_LENGTH query and the buffer query implementations have
            // very commonly off-by-one errors. Try to work around these issues.

            // add tolerance for off-by-one in log length, buffer write, and for terminator
            std::vector<char> infoLog(infoLogLen + 3, '\0');

            // claim buf size is one smaller to protect from off-by-one writing over buffer bounds
            m_gl.getShaderInfoLog(m_shader, (int)infoLog.size() - 1, &unusedLen, &infoLog[0]);

            if (infoLog[(int)(infoLog.size()) - 1] != '\0')
            {
                // return whole buffer if null terminator was overwritten
                m_info.infoLog = std::string(&infoLog[0], infoLog.size());
            }
            else
            {
                // read as C string. infoLog is guaranteed to be 0-terminated
                m_info.infoLog = std::string(&infoLog[0]);
            }
        }
    }
}

void Shader::specialize(const char *entryPoint, glw::GLuint numSpecializationConstants,
                        const glw::GLuint *constantIndex, const glw::GLuint *constantValue)
{
    m_info.compileOk     = false;
    m_info.compileTimeUs = 0;
    m_info.infoLog.clear();

    {
        uint64_t compileStart = deGetMicroseconds();
        m_gl.specializeShader(m_shader, entryPoint, numSpecializationConstants, constantIndex, constantValue);
        m_info.compileTimeUs = deGetMicroseconds() - compileStart;
    }

    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glSpecializeShader()");

    // Query status
    {
        int compileStatus = 0;

        m_gl.getShaderiv(m_shader, GL_COMPILE_STATUS, &compileStatus);
        GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderiv()");

        m_info.compileOk = compileStatus != GL_FALSE;
    }

    // Query log
    {
        int infoLogLen = 0;
        int unusedLen;

        m_gl.getShaderiv(m_shader, GL_INFO_LOG_LENGTH, &infoLogLen);
        GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderiv()");

        if (infoLogLen > 0)
        {
            // The INFO_LOG_LENGTH query and the buffer query implementations have
            // very commonly off-by-one errors. Try to work around these issues.

            // add tolerance for off-by-one in log length, buffer write, and for terminator
            std::vector<char> infoLog(infoLogLen + 3, '\0');

            // claim buf size is one smaller to protect from off-by-one writing over buffer bounds
            m_gl.getShaderInfoLog(m_shader, (int)infoLog.size() - 1, &unusedLen, &infoLog[0]);
            GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetShaderInfoLog()");

            if (infoLog[(int)(infoLog.size()) - 1] != '\0')
            {
                // return whole buffer if null terminator was overwritten
                m_info.infoLog = std::string(&infoLog[0], infoLog.size());
            }
            else
            {
                // read as C string. infoLog is guaranteed to be 0-terminated
                m_info.infoLog = std::string(&infoLog[0]);
            }
        }
    }
}

// Program

static bool getProgramLinkStatus(const glw::Functions &gl, uint32_t program)
{
    int linkStatus = 0;

    gl.getProgramiv(program, GL_LINK_STATUS, &linkStatus);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv()");
    return (linkStatus != GL_FALSE);
}

static std::string getProgramInfoLog(const glw::Functions &gl, uint32_t program)
{
    int infoLogLen = 0;
    int unusedLen;

    gl.getProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLen);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv()");

    if (infoLogLen > 0)
    {
        // The INFO_LOG_LENGTH query and the buffer query implementations have
        // very commonly off-by-one errors. Try to work around these issues.

        // add tolerance for off-by-one in log length, buffer write, and for terminator
        std::vector<char> infoLog(infoLogLen + 3, '\0');

        // claim buf size is one smaller to protect from off-by-one writing over buffer bounds
        gl.getProgramInfoLog(program, (int)infoLog.size() - 1, &unusedLen, &infoLog[0]);

        // return whole buffer if null terminator was overwritten
        if (infoLog[(int)(infoLog.size()) - 1] != '\0')
            return std::string(&infoLog[0], infoLog.size());

        // read as C string. infoLog is guaranteed to be 0-terminated
        return std::string(&infoLog[0]);
    }
    return std::string();
}

Program::Program(const RenderContext &renderCtx) : m_gl(renderCtx.getFunctions()), m_program(0)
{
    m_program = m_gl.createProgram();
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCreateProgram()");
}

Program::Program(const glw::Functions &gl) : m_gl(gl), m_program(0)
{
    m_program = m_gl.createProgram();
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glCreateProgram()");
}

Program::Program(const RenderContext &renderCtx, uint32_t program) : m_gl(renderCtx.getFunctions()), m_program(program)
{
    m_info.linkOk  = getProgramLinkStatus(m_gl, program);
    m_info.infoLog = getProgramInfoLog(m_gl, program);
}

Program::~Program(void)
{
    m_gl.deleteProgram(m_program);
}

void Program::attachShader(uint32_t shader)
{
    m_gl.attachShader(m_program, shader);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glAttachShader()");
}

void Program::detachShader(uint32_t shader)
{
    m_gl.detachShader(m_program, shader);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glDetachShader()");
}

void Program::bindAttribLocation(uint32_t location, const char *name)
{
    m_gl.bindAttribLocation(m_program, location, name);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glBindAttribLocation()");
}

void Program::transformFeedbackVaryings(int count, const char *const *varyings, uint32_t bufferMode)
{
    m_gl.transformFeedbackVaryings(m_program, count, varyings, bufferMode);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glTransformFeedbackVaryings()");
}

void Program::link(void)
{
    m_info.linkOk     = false;
    m_info.linkTimeUs = 0;
    m_info.infoLog.clear();

    {
        uint64_t linkStart = deGetMicroseconds();
        m_gl.linkProgram(m_program);
        m_info.linkTimeUs = deGetMicroseconds() - linkStart;
    }
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glLinkProgram()");

    m_info.linkOk  = getProgramLinkStatus(m_gl, m_program);
    m_info.infoLog = getProgramInfoLog(m_gl, m_program);
}

bool Program::isSeparable(void) const
{
    int separable = GL_FALSE;

    m_gl.getProgramiv(m_program, GL_PROGRAM_SEPARABLE, &separable);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGetProgramiv()");

    return (separable != GL_FALSE);
}

void Program::setSeparable(bool separable)
{
    m_gl.programParameteri(m_program, GL_PROGRAM_SEPARABLE, separable);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glProgramParameteri()");
}

// ProgramPipeline

ProgramPipeline::ProgramPipeline(const RenderContext &renderCtx) : m_gl(renderCtx.getFunctions()), m_pipeline(0)
{
    m_gl.genProgramPipelines(1, &m_pipeline);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGenProgramPipelines()");
}

ProgramPipeline::ProgramPipeline(const glw::Functions &gl) : m_gl(gl), m_pipeline(0)
{
    m_gl.genProgramPipelines(1, &m_pipeline);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glGenProgramPipelines()");
}

ProgramPipeline::~ProgramPipeline(void)
{
    m_gl.deleteProgramPipelines(1, &m_pipeline);
}

void ProgramPipeline::useProgramStages(uint32_t stages, uint32_t program)
{
    m_gl.useProgramStages(m_pipeline, stages, program);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glUseProgramStages()");
}

void ProgramPipeline::activeShaderProgram(uint32_t program)
{
    m_gl.activeShaderProgram(m_pipeline, program);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glActiveShaderProgram()");
}

bool ProgramPipeline::isValid(void)
{
    glw::GLint status = GL_FALSE;
    m_gl.validateProgramPipeline(m_pipeline);
    GLU_EXPECT_NO_ERROR(m_gl.getError(), "glValidateProgramPipeline()");

    m_gl.getProgramPipelineiv(m_pipeline, GL_VALIDATE_STATUS, &status);

    return (status != GL_FALSE);
}

// ShaderProgram

ShaderProgram::ShaderProgram(const RenderContext &renderCtx, const ProgramSources &sources)
    : m_program(renderCtx.getFunctions())
{
    init(renderCtx.getFunctions(), sources);
}

ShaderProgram::ShaderProgram(const RenderContext &renderCtx, const ProgramBinaries &binaries)
    : m_program(renderCtx.getFunctions())
{
    init(renderCtx.getFunctions(), binaries);
}

ShaderProgram::ShaderProgram(const glw::Functions &gl, const ProgramSources &sources) : m_program(gl)
{
    init(gl, sources);
}

ShaderProgram::ShaderProgram(const glw::Functions &gl, const ProgramBinaries &binaries) : m_program(gl)
{
    init(gl, binaries);
}

void ShaderProgram::init(const glw::Functions &gl, const ProgramSources &sources)
{
    try
    {
        bool shadersOk = true;

        for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
        {
            for (int shaderNdx = 0; shaderNdx < (int)sources.sources[shaderType].size(); ++shaderNdx)
            {
                const char *source = sources.sources[shaderType][shaderNdx].c_str();
                const int length   = (int)sources.sources[shaderType][shaderNdx].size();

                m_shaders[shaderType].reserve(m_shaders[shaderType].size() + 1);

                m_shaders[shaderType].push_back(new Shader(gl, ShaderType(shaderType)));
                m_shaders[shaderType].back()->setSources(1, &source, &length);
                m_shaders[shaderType].back()->compile();

                shadersOk = shadersOk && m_shaders[shaderType].back()->getCompileStatus();
            }
        }

        if (shadersOk)
        {
            for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
                for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
                    m_program.attachShader(m_shaders[shaderType][shaderNdx]->getShader());

            for (std::vector<AttribLocationBinding>::const_iterator binding = sources.attribLocationBindings.begin();
                 binding != sources.attribLocationBindings.end(); ++binding)
                m_program.bindAttribLocation(binding->location, binding->name.c_str());

            DE_ASSERT((sources.transformFeedbackBufferMode == GL_NONE) == sources.transformFeedbackVaryings.empty());
            if (sources.transformFeedbackBufferMode != GL_NONE)
            {
                std::vector<const char *> tfVaryings(sources.transformFeedbackVaryings.size());
                for (int ndx = 0; ndx < (int)tfVaryings.size(); ndx++)
                    tfVaryings[ndx] = sources.transformFeedbackVaryings[ndx].c_str();

                m_program.transformFeedbackVaryings((int)tfVaryings.size(), &tfVaryings[0],
                                                    sources.transformFeedbackBufferMode);
            }

            if (sources.separable)
                m_program.setSeparable(true);

            m_program.link();
        }
    }
    catch (...)
    {
        for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
            for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
                delete m_shaders[shaderType][shaderNdx];
        throw;
    }
}

void ShaderProgram::init(const glw::Functions &gl, const ProgramBinaries &binaries)
{
    try
    {
        bool shadersOk = true;

        for (uint32_t binaryNdx = 0; binaryNdx < binaries.binaries.size(); ++binaryNdx)
        {
            ShaderBinary shaderBinary = binaries.binaries[binaryNdx];
            if (!shaderBinary.binary.empty())
            {
                const char *binary = (const char *)shaderBinary.binary.data();
                const int length   = (int)(shaderBinary.binary.size() * sizeof(uint32_t));

                DE_ASSERT(shaderBinary.shaderEntryPoints.size() == shaderBinary.shaderTypes.size());

                std::vector<Shader *> shaders;
                for (uint32_t shaderTypeNdx = 0; shaderTypeNdx < shaderBinary.shaderTypes.size(); ++shaderTypeNdx)
                {
                    ShaderType shaderType = shaderBinary.shaderTypes[shaderTypeNdx];

                    Shader *shader = new Shader(gl, ShaderType(shaderType));

                    m_shaders[shaderType].reserve(m_shaders[shaderType].size() + 1);
                    m_shaders[shaderType].push_back(shader);
                    shaders.push_back(shader);
                }

                setBinary(gl, shaders, binaries.binaryFormat, binary, length);

                for (uint32_t shaderNdx = 0; shaderNdx < shaders.size(); ++shaderNdx)
                {
                    shaders[shaderNdx]->specialize(shaderBinary.shaderEntryPoints[shaderNdx].c_str(),
                                                   (uint32_t)shaderBinary.specializationIndices.size(),
                                                   shaderBinary.specializationIndices.data(),
                                                   shaderBinary.specializationValues.data());

                    shadersOk = shadersOk && shaders[shaderNdx]->getCompileStatus();
                }
            }
        }

        if (shadersOk)
        {
            for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
                for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
                    m_program.attachShader(m_shaders[shaderType][shaderNdx]->getShader());

            m_program.link();
        }
    }
    catch (...)
    {
        for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
            for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
                delete m_shaders[shaderType][shaderNdx];
        throw;
    }
}

void ShaderProgram::setBinary(const glw::Functions &gl, std::vector<Shader *> &shaders, glw::GLenum binaryFormat,
                              const void *binaryData, const int length)
{
    std::vector<glw::GLuint> shaderVec;
    for (uint32_t shaderNdx = 0; shaderNdx < shaders.size(); ++shaderNdx)
        shaderVec.push_back(shaders[shaderNdx]->getShader());

    gl.shaderBinary((glw::GLsizei)shaderVec.size(), shaderVec.data(), binaryFormat, binaryData, length);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderBinary");

    for (uint32_t shaderNdx = 0; shaderNdx < shaders.size(); ++shaderNdx)
    {
        glw::GLint shaderState;
        gl.getShaderiv(shaders[shaderNdx]->getShader(), GL_SPIR_V_BINARY_ARB, &shaderState);
        GLU_EXPECT_NO_ERROR(gl.getError(), "getShaderiv");

        DE_ASSERT(shaderState == GL_TRUE);
    }
}

ShaderProgram::~ShaderProgram(void)
{
    for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
        for (int shaderNdx = 0; shaderNdx < (int)m_shaders[shaderType].size(); ++shaderNdx)
            delete m_shaders[shaderType][shaderNdx];
}

// Utilities

uint32_t getGLShaderType(ShaderType shaderType)
{
    static const uint32_t s_typeMap[] = {
        GL_VERTEX_SHADER,
        GL_FRAGMENT_SHADER,
        GL_GEOMETRY_SHADER,
        GL_TESS_CONTROL_SHADER,
        GL_TESS_EVALUATION_SHADER,
        GL_COMPUTE_SHADER,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
    };
    DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_typeMap) == SHADERTYPE_LAST);
    DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_typeMap)));
    return s_typeMap[shaderType];
}

uint32_t getGLShaderTypeBit(ShaderType shaderType)
{
    static const uint32_t s_typebitMap[] = {
        GL_VERTEX_SHADER_BIT,
        GL_FRAGMENT_SHADER_BIT,
        GL_GEOMETRY_SHADER_BIT,
        GL_TESS_CONTROL_SHADER_BIT,
        GL_TESS_EVALUATION_SHADER_BIT,
        GL_COMPUTE_SHADER_BIT,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
    };
    DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_typebitMap) == SHADERTYPE_LAST);
    DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_typebitMap)));
    return s_typebitMap[shaderType];
}

qpShaderType getLogShaderType(ShaderType shaderType)
{
    static const qpShaderType s_typeMap[] = {
        QP_SHADER_TYPE_VERTEX,
        QP_SHADER_TYPE_FRAGMENT,
        QP_SHADER_TYPE_GEOMETRY,
        QP_SHADER_TYPE_TESS_CONTROL,
        QP_SHADER_TYPE_TESS_EVALUATION,
        QP_SHADER_TYPE_COMPUTE,
        QP_SHADER_TYPE_RAYGEN,
        QP_SHADER_TYPE_ANY_HIT,
        QP_SHADER_TYPE_CLOSEST_HIT,
        QP_SHADER_TYPE_MISS,
        QP_SHADER_TYPE_INTERSECTION,
        QP_SHADER_TYPE_CALLABLE,
        QP_SHADER_TYPE_TASK,
        QP_SHADER_TYPE_MESH,
    };
    DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_typeMap) == SHADERTYPE_LAST);
    DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_typeMap)));
    return s_typeMap[shaderType];
}

tcu::TestLog &operator<<(tcu::TestLog &log, const ShaderInfo &shaderInfo)
{
    return log << tcu::TestLog::Shader(getLogShaderType(shaderInfo.type), shaderInfo.source, shaderInfo.compileOk,
                                       shaderInfo.infoLog);
}

tcu::TestLog &operator<<(tcu::TestLog &log, const Shader &shader)
{
    return log << tcu::TestLog::ShaderProgram(false, "Plain shader") << shader.getInfo()
               << tcu::TestLog::EndShaderProgram;
}

static void logShaderProgram(tcu::TestLog &log, const ProgramInfo &programInfo, size_t numShaders,
                             const ShaderInfo *const *shaderInfos)
{
    log << tcu::TestLog::ShaderProgram(programInfo.linkOk, programInfo.infoLog);
    try
    {
        for (size_t shaderNdx = 0; shaderNdx < numShaders; ++shaderNdx)
            log << *shaderInfos[shaderNdx];
    }
    catch (...)
    {
        log << tcu::TestLog::EndShaderProgram;
        throw;
    }
    log << tcu::TestLog::EndShaderProgram;

    // Write statistics.
    {
        static const struct
        {
            const char *name;
            const char *description;
        } s_compileTimeDesc[] = {
            {"VertexCompileTime", "Vertex shader compile time"},
            {"FragmentCompileTime", "Fragment shader compile time"},
            {"GeometryCompileTime", "Geometry shader compile time"},
            {"TessControlCompileTime", "Tesselation control shader compile time"},
            {"TessEvaluationCompileTime", "Tesselation evaluation shader compile time"},
            {"ComputeCompileTime", "Compute shader compile time"},
            {"RaygenCompileTime", "Raygen shader compile time"},
            {"AnyHitCompileTime", "Any hit shader compile time"},
            {"ClosestHitCompileTime", "Closest hit shader compile time"},
            {"MissCompileTime", "Miss shader compile time"},
            {"IntersectionCompileTime", "Intersection shader compile time"},
            {"CallableCompileTime", "Callable shader compile time"},
            {"TaskCompileTime", "Task shader compile time"},
            {"MeshCompileTime", "Mesh shader compile time"},
        };
        DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_compileTimeDesc) == SHADERTYPE_LAST);

        bool allShadersOk = true;

        for (size_t shaderNdx = 0; shaderNdx < numShaders; ++shaderNdx)
        {
            const ShaderInfo &shaderInfo = *shaderInfos[shaderNdx];

            log << tcu::TestLog::Float(s_compileTimeDesc[shaderInfo.type].name,
                                       s_compileTimeDesc[shaderInfo.type].description, "ms", QP_KEY_TAG_TIME,
                                       (float)shaderInfo.compileTimeUs / 1000.0f);

            allShadersOk = allShadersOk && shaderInfo.compileOk;
        }

        if (allShadersOk)
            log << tcu::TestLog::Float("LinkTime", "Link time", "ms", QP_KEY_TAG_TIME,
                                       (float)programInfo.linkTimeUs / 1000.0f);
    }
}

tcu::TestLog &operator<<(tcu::TestLog &log, const ShaderProgramInfo &shaderProgramInfo)
{
    std::vector<const ShaderInfo *> shaderPtrs(shaderProgramInfo.shaders.size());

    for (size_t ndx = 0; ndx < shaderPtrs.size(); ndx++)
        shaderPtrs[ndx] = &shaderProgramInfo.shaders[ndx];

    logShaderProgram(log, shaderProgramInfo.program, shaderPtrs.size(), shaderPtrs.empty() ? DE_NULL : &shaderPtrs[0]);

    return log;
}

tcu::TestLog &operator<<(tcu::TestLog &log, const ShaderProgram &shaderProgram)
{
    std::vector<const ShaderInfo *> shaderPtrs;

    for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
    {
        for (int shaderNdx = 0; shaderNdx < shaderProgram.getNumShaders((ShaderType)shaderType); shaderNdx++)
            shaderPtrs.push_back(&shaderProgram.getShaderInfo((ShaderType)shaderType, shaderNdx));
    }

    logShaderProgram(log, shaderProgram.getProgramInfo(), shaderPtrs.size(),
                     shaderPtrs.empty() ? DE_NULL : &shaderPtrs[0]);

    return log;
}

tcu::TestLog &operator<<(tcu::TestLog &log, const ProgramSources &sources)
{
    log << tcu::TestLog::ShaderProgram(false, "(Source only)");

    try
    {
        for (int shaderType = 0; shaderType < SHADERTYPE_LAST; shaderType++)
        {
            for (size_t shaderNdx = 0; shaderNdx < sources.sources[shaderType].size(); shaderNdx++)
            {
                log << tcu::TestLog::Shader(getLogShaderType((ShaderType)shaderType),
                                            sources.sources[shaderType][shaderNdx], false, "");
            }
        }
    }
    catch (...)
    {
        log << tcu::TestLog::EndShaderProgram;
        throw;
    }

    log << tcu::TestLog::EndShaderProgram;

    return log;
}

} // namespace glu