tor-browser

Program.cpp (126745B)

---

//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// Program.cpp: Implements the gl::Program class. Implements GL program objects
// and related functionality. [OpenGL ES 2.0.24] section 2.10.3 page 28.

#include "libANGLE/Program.h"

#include <algorithm>
#include <utility>

#include "common/angle_version_info.h"
#include "common/bitset_utils.h"
#include "common/debug.h"
#include "common/platform.h"
#include "common/string_utils.h"
#include "common/utilities.h"
#include "compiler/translator/blocklayout.h"
#include "libANGLE/Context.h"
#include "libANGLE/ErrorStrings.h"
#include "libANGLE/MemoryProgramCache.h"
#include "libANGLE/ProgramLinkedResources.h"
#include "libANGLE/ResourceManager.h"
#include "libANGLE/Uniform.h"
#include "libANGLE/VaryingPacking.h"
#include "libANGLE/Version.h"
#include "libANGLE/capture/FrameCapture.h"
#include "libANGLE/features.h"
#include "libANGLE/histogram_macros.h"
#include "libANGLE/queryconversions.h"
#include "libANGLE/renderer/GLImplFactory.h"
#include "libANGLE/renderer/ProgramImpl.h"
#include "platform/FrontendFeatures_autogen.h"
#include "platform/PlatformMethods.h"

namespace gl
{

namespace
{

// This simplified cast function doesn't need to worry about advanced concepts like
// depth range values, or casting to bool.
template <typename DestT, typename SrcT>
DestT UniformStateQueryCast(SrcT value);

// From-Float-To-Integer Casts
template <>
GLint UniformStateQueryCast(GLfloat value)
{
   return clampCast<GLint>(roundf(value));
}

template <>
GLuint UniformStateQueryCast(GLfloat value)
{
   return clampCast<GLuint>(roundf(value));
}

// From-Integer-to-Integer Casts
template <>
GLint UniformStateQueryCast(GLuint value)
{
   return clampCast<GLint>(value);
}

template <>
GLuint UniformStateQueryCast(GLint value)
{
   return clampCast<GLuint>(value);
}

// From-Boolean-to-Anything Casts
template <>
GLfloat UniformStateQueryCast(GLboolean value)
{
   return (ConvertToBool(value) ? 1.0f : 0.0f);
}

template <>
GLint UniformStateQueryCast(GLboolean value)
{
   return (ConvertToBool(value) ? 1 : 0);
}

template <>
GLuint UniformStateQueryCast(GLboolean value)
{
   return (ConvertToBool(value) ? 1u : 0u);
}

// Default to static_cast
template <typename DestT, typename SrcT>
DestT UniformStateQueryCast(SrcT value)
{
   return static_cast<DestT>(value);
}

template <typename SrcT, typename DestT>
void UniformStateQueryCastLoop(DestT *dataOut, const uint8_t *srcPointer, int components)
{
   for (int comp = 0; comp < components; ++comp)
   {
       // We only work with strides of 4 bytes for uniform components. (GLfloat/GLint)
       // Don't use SrcT stride directly since GLboolean has a stride of 1 byte.
       size_t offset               = comp * 4;
       const SrcT *typedSrcPointer = reinterpret_cast<const SrcT *>(&srcPointer[offset]);
       dataOut[comp]               = UniformStateQueryCast<DestT>(*typedSrcPointer);
   }
}

template <typename VarT>
GLuint GetResourceIndexFromName(const std::vector<VarT> &list, const std::string &name)
{
   std::string nameAsArrayName = name + "[0]";
   for (size_t index = 0; index < list.size(); index++)
   {
       const VarT &resource = list[index];
       if (resource.name == name || (resource.isArray() && resource.name == nameAsArrayName))
       {
           return static_cast<GLuint>(index);
       }
   }

   return GL_INVALID_INDEX;
}

GLint GetVariableLocation(const std::vector<sh::ShaderVariable> &list,
                         const std::vector<VariableLocation> &locationList,
                         const std::string &name)
{
   size_t nameLengthWithoutArrayIndex;
   unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex);

   for (size_t location = 0u; location < locationList.size(); ++location)
   {
       const VariableLocation &variableLocation = locationList[location];
       if (!variableLocation.used())
       {
           continue;
       }

       const sh::ShaderVariable &variable = list[variableLocation.index];

       // Array output variables may be bound out of order, so we need to ensure we only pick the
       // first element if given the base name.
       if ((variable.name == name) && (variableLocation.arrayIndex == 0))
       {
           return static_cast<GLint>(location);
       }
       if (variable.isArray() && variableLocation.arrayIndex == arrayIndex &&
           angle::BeginsWith(variable.name, name, nameLengthWithoutArrayIndex))
       {
           return static_cast<GLint>(location);
       }
   }

   return -1;
}

GLint GetVariableLocation(const std::vector<LinkedUniform> &list,
                         const std::vector<VariableLocation> &locationList,
                         const std::string &name)
{
   size_t nameLengthWithoutArrayIndex;
   unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex);

   for (size_t location = 0u; location < locationList.size(); ++location)
   {
       const VariableLocation &variableLocation = locationList[location];
       if (!variableLocation.used())
       {
           continue;
       }

       const LinkedUniform &variable = list[variableLocation.index];

       // Array output variables may be bound out of order, so we need to ensure we only pick the
       // first element if given the base name. Uniforms don't allow this behavior and some code
       // seemingly depends on the opposite behavior, so only enable it for output variables.
       if (angle::BeginsWith(variable.name, name) && (variableLocation.arrayIndex == 0))
       {
           if (name.length() == variable.name.length())
           {
               ASSERT(name == variable.name);
               // GLES 3.1 November 2016 page 87.
               // The string exactly matches the name of the active variable.
               return static_cast<GLint>(location);
           }
           if (name.length() + 3u == variable.name.length() && variable.isArray())
           {
               ASSERT(name + "[0]" == variable.name);
               // The string identifies the base name of an active array, where the string would
               // exactly match the name of the variable if the suffix "[0]" were appended to the
               // string.
               return static_cast<GLint>(location);
           }
       }
       if (variable.isArray() && variableLocation.arrayIndex == arrayIndex &&
           nameLengthWithoutArrayIndex + 3u == variable.name.length() &&
           angle::BeginsWith(variable.name, name, nameLengthWithoutArrayIndex))
       {
           ASSERT(name.substr(0u, nameLengthWithoutArrayIndex) + "[0]" == variable.name);
           // The string identifies an active element of the array, where the string ends with the
           // concatenation of the "[" character, an integer (with no "+" sign, extra leading
           // zeroes, or whitespace) identifying an array element, and the "]" character, the
           // integer is less than the number of active elements of the array variable, and where
           // the string would exactly match the enumerated name of the array if the decimal
           // integer were replaced with zero.
           return static_cast<GLint>(location);
       }
   }

   return -1;
}

void CopyStringToBuffer(GLchar *buffer,
                       const std::string &string,
                       GLsizei bufSize,
                       GLsizei *lengthOut)
{
   ASSERT(bufSize > 0);
   size_t length = std::min<size_t>(bufSize - 1, string.length());
   memcpy(buffer, string.c_str(), length);
   buffer[length] = '\0';

   if (lengthOut)
   {
       *lengthOut = static_cast<GLsizei>(length);
   }
}

GLuint GetInterfaceBlockIndex(const std::vector<InterfaceBlock> &list, const std::string &name)
{
   std::vector<unsigned int> subscripts;
   std::string baseName = ParseResourceName(name, &subscripts);

   unsigned int numBlocks = static_cast<unsigned int>(list.size());
   for (unsigned int blockIndex = 0; blockIndex < numBlocks; blockIndex++)
   {
       const auto &block = list[blockIndex];
       if (block.name == baseName)
       {
           const bool arrayElementZero =
               (subscripts.empty() && (!block.isArray || block.arrayElement == 0));
           const bool arrayElementMatches =
               (subscripts.size() == 1 && subscripts[0] == block.arrayElement);
           if (arrayElementMatches || arrayElementZero)
           {
               return blockIndex;
           }
       }
   }

   return GL_INVALID_INDEX;
}

void GetInterfaceBlockName(const UniformBlockIndex index,
                          const std::vector<InterfaceBlock> &list,
                          GLsizei bufSize,
                          GLsizei *length,
                          GLchar *name)
{
   ASSERT(index.value < list.size());

   const auto &block = list[index.value];

   if (bufSize > 0)
   {
       std::string blockName = block.name;

       if (block.isArray)
       {
           blockName += ArrayString(block.arrayElement);
       }
       CopyStringToBuffer(name, blockName, bufSize, length);
   }
}

void InitUniformBlockLinker(const Context *context,
                           const ProgramState &state,
                           UniformBlockLinker *blockLinker)
{
   for (ShaderType shaderType : AllShaderTypes())
   {
       Shader *shader = state.getAttachedShader(shaderType);
       if (shader)
       {
           blockLinker->addShaderBlocks(shaderType, &shader->getUniformBlocks(context));
       }
   }
}

void InitShaderStorageBlockLinker(const Context *context,
                                 const ProgramState &state,
                                 ShaderStorageBlockLinker *blockLinker)
{
   for (ShaderType shaderType : AllShaderTypes())
   {
       Shader *shader = state.getAttachedShader(shaderType);
       if (shader != nullptr)
       {
           blockLinker->addShaderBlocks(shaderType, &shader->getShaderStorageBlocks(context));
       }
   }
}
}  // anonymous namespace

const char *GetLinkMismatchErrorString(LinkMismatchError linkError)
{
   switch (linkError)
   {
       case LinkMismatchError::TYPE_MISMATCH:
           return "Type";
       case LinkMismatchError::ARRAYNESS_MISMATCH:
           return "Array-ness";
       case LinkMismatchError::ARRAY_SIZE_MISMATCH:
           return "Array size";
       case LinkMismatchError::PRECISION_MISMATCH:
           return "Precision";
       case LinkMismatchError::STRUCT_NAME_MISMATCH:
           return "Structure name";
       case LinkMismatchError::FIELD_NUMBER_MISMATCH:
           return "Field number";
       case LinkMismatchError::FIELD_NAME_MISMATCH:
           return "Field name";

       case LinkMismatchError::INTERPOLATION_TYPE_MISMATCH:
           return "Interpolation type";
       case LinkMismatchError::INVARIANCE_MISMATCH:
           return "Invariance";

       case LinkMismatchError::BINDING_MISMATCH:
           return "Binding layout qualifier";
       case LinkMismatchError::LOCATION_MISMATCH:
           return "Location layout qualifier";
       case LinkMismatchError::OFFSET_MISMATCH:
           return "Offset layout qualifier";
       case LinkMismatchError::INSTANCE_NAME_MISMATCH:
           return "Instance name qualifier";
       case LinkMismatchError::FORMAT_MISMATCH:
           return "Format qualifier";

       case LinkMismatchError::LAYOUT_QUALIFIER_MISMATCH:
           return "Layout qualifier";
       case LinkMismatchError::MATRIX_PACKING_MISMATCH:
           return "Matrix Packing";

       case LinkMismatchError::FIELD_LOCATION_MISMATCH:
           return "Field location";
       case LinkMismatchError::FIELD_STRUCT_NAME_MISMATCH:
           return "Field structure name";
       default:
           UNREACHABLE();
           return "";
   }
}

void UpdateInterfaceVariable(std::vector<sh::ShaderVariable> *block, const sh::ShaderVariable &var)
{
   if (!var.isStruct())
   {
       block->emplace_back(var);
       block->back().resetEffectiveLocation();
   }

   for (const sh::ShaderVariable &field : var.fields)
   {
       ASSERT(!var.name.empty() || var.isShaderIOBlock);

       // Shader I/O block naming is similar to UBOs and SSBOs:
       //
       //     in Block
       //     {
       //         type field;  // produces "field"
       //     };
       //
       //     in Block2
       //     {
       //         type field;  // produces "Block2.field"
       //     } block2;
       //
       const std::string &baseName = var.isShaderIOBlock ? var.structOrBlockName : var.name;
       const std::string prefix    = var.name.empty() ? "" : baseName + ".";

       if (!field.isStruct())
       {
           sh::ShaderVariable fieldCopy = field;
           fieldCopy.updateEffectiveLocation(var);
           fieldCopy.name = prefix + field.name;
           block->emplace_back(fieldCopy);
       }

       for (const sh::ShaderVariable &nested : field.fields)
       {
           sh::ShaderVariable nestedCopy = nested;
           nestedCopy.updateEffectiveLocation(field);
           nestedCopy.name = prefix + field.name + "." + nested.name;
           block->emplace_back(nestedCopy);
       }
   }
}

void WriteShaderVariableBuffer(BinaryOutputStream *stream, const ShaderVariableBuffer &var)
{
   stream->writeInt(var.binding);
   stream->writeInt(var.dataSize);

   for (ShaderType shaderType : AllShaderTypes())
   {
       stream->writeBool(var.isActive(shaderType));
   }

   stream->writeInt(var.memberIndexes.size());
   for (unsigned int memberCounterIndex : var.memberIndexes)
   {
       stream->writeInt(memberCounterIndex);
   }
}

void LoadShaderVariableBuffer(BinaryInputStream *stream, ShaderVariableBuffer *var)
{
   var->binding  = stream->readInt<int>();
   var->dataSize = stream->readInt<unsigned int>();

   for (ShaderType shaderType : AllShaderTypes())
   {
       var->setActive(shaderType, stream->readBool());
   }

   size_t numMembers = stream->readInt<size_t>();
   for (size_t blockMemberIndex = 0; blockMemberIndex < numMembers; blockMemberIndex++)
   {
       var->memberIndexes.push_back(stream->readInt<unsigned int>());
   }
}

void WriteBufferVariable(BinaryOutputStream *stream, const BufferVariable &var)
{
   WriteShaderVar(stream, var);

   stream->writeInt(var.bufferIndex);
   WriteBlockMemberInfo(stream, var.blockInfo);
   stream->writeInt(var.topLevelArraySize);

   for (ShaderType shaderType : AllShaderTypes())
   {
       stream->writeBool(var.isActive(shaderType));
   }
}

void LoadBufferVariable(BinaryInputStream *stream, BufferVariable *var)
{
   LoadShaderVar(stream, var);

   var->bufferIndex = stream->readInt<int>();
   LoadBlockMemberInfo(stream, &var->blockInfo);
   var->topLevelArraySize = stream->readInt<int>();

   for (ShaderType shaderType : AllShaderTypes())
   {
       var->setActive(shaderType, stream->readBool());
   }
}

void WriteInterfaceBlock(BinaryOutputStream *stream, const InterfaceBlock &block)
{
   stream->writeString(block.name);
   stream->writeString(block.mappedName);
   stream->writeBool(block.isArray);
   stream->writeInt(block.arrayElement);

   WriteShaderVariableBuffer(stream, block);
}

void LoadInterfaceBlock(BinaryInputStream *stream, InterfaceBlock *block)
{
   block->name         = stream->readString();
   block->mappedName   = stream->readString();
   block->isArray      = stream->readBool();
   block->arrayElement = stream->readInt<unsigned int>();

   LoadShaderVariableBuffer(stream, block);
}

void WriteShInterfaceBlock(BinaryOutputStream *stream, const sh::InterfaceBlock &block)
{
   stream->writeString(block.name);
   stream->writeString(block.mappedName);
   stream->writeString(block.instanceName);
   stream->writeInt(block.arraySize);
   stream->writeEnum(block.layout);
   stream->writeBool(block.isRowMajorLayout);
   stream->writeInt(block.binding);
   stream->writeBool(block.staticUse);
   stream->writeBool(block.active);
   stream->writeEnum(block.blockType);

   stream->writeInt<size_t>(block.fields.size());
   for (const sh::ShaderVariable &shaderVariable : block.fields)
   {
       WriteShaderVar(stream, shaderVariable);
   }
}

void LoadShInterfaceBlock(BinaryInputStream *stream, sh::InterfaceBlock *block)
{
   block->name             = stream->readString();
   block->mappedName       = stream->readString();
   block->instanceName     = stream->readString();
   block->arraySize        = stream->readInt<unsigned int>();
   block->layout           = stream->readEnum<sh::BlockLayoutType>();
   block->isRowMajorLayout = stream->readBool();
   block->binding          = stream->readInt<int>();
   block->staticUse        = stream->readBool();
   block->active           = stream->readBool();
   block->blockType        = stream->readEnum<sh::BlockType>();

   block->fields.resize(stream->readInt<size_t>());
   for (sh::ShaderVariable &variable : block->fields)
   {
       LoadShaderVar(stream, &variable);
   }
}

// Saves the linking context for later use in resolveLink().
struct Program::LinkingState
{
   std::shared_ptr<ProgramExecutable> linkedExecutable;
   ProgramLinkedResources resources;
   egl::BlobCache::Key programHash;
   std::unique_ptr<rx::LinkEvent> linkEvent;
   bool linkingFromBinary;
};

const char *const g_fakepath = "C:\\fakepath";

// InfoLog implementation.
InfoLog::InfoLog() : mLazyStream(nullptr) {}

InfoLog::~InfoLog() {}

size_t InfoLog::getLength() const
{
   if (!mLazyStream)
   {
       return 0;
   }

   const std::string &logString = mLazyStream->str();
   return logString.empty() ? 0 : logString.length() + 1;
}

void InfoLog::getLog(GLsizei bufSize, GLsizei *length, char *infoLog) const
{
   size_t index = 0;

   if (bufSize > 0)
   {
       const std::string logString(str());

       if (!logString.empty())
       {
           index = std::min(static_cast<size_t>(bufSize) - 1, logString.length());
           memcpy(infoLog, logString.c_str(), index);
       }

       infoLog[index] = '\0';
   }

   if (length)
   {
       *length = static_cast<GLsizei>(index);
   }
}

// append a sanitized message to the program info log.
// The D3D compiler includes a fake file path in some of the warning or error
// messages, so lets remove all occurrences of this fake file path from the log.
void InfoLog::appendSanitized(const char *message)
{
   ensureInitialized();

   std::string msg(message);

   size_t found;
   do
   {
       found = msg.find(g_fakepath);
       if (found != std::string::npos)
       {
           msg.erase(found, strlen(g_fakepath));
       }
   } while (found != std::string::npos);

   if (!msg.empty())
   {
       *mLazyStream << message << std::endl;
   }
}

void InfoLog::reset()
{
   if (mLazyStream)
   {
       mLazyStream.reset(nullptr);
   }
}

bool InfoLog::empty() const
{
   if (!mLazyStream)
   {
       return true;
   }

   return mLazyStream->rdbuf()->in_avail() == 0;
}

void LogLinkMismatch(InfoLog &infoLog,
                    const std::string &variableName,
                    const char *variableType,
                    LinkMismatchError linkError,
                    const std::string &mismatchedStructOrBlockFieldName,
                    ShaderType shaderType1,
                    ShaderType shaderType2)
{
   std::ostringstream stream;
   stream << GetLinkMismatchErrorString(linkError) << "s of " << variableType << " '"
          << variableName;

   if (!mismatchedStructOrBlockFieldName.empty())
   {
       stream << "' member '" << variableName << "." << mismatchedStructOrBlockFieldName;
   }

   stream << "' differ between " << GetShaderTypeString(shaderType1) << " and "
          << GetShaderTypeString(shaderType2) << " shaders.";

   infoLog << stream.str();
}

bool IsActiveInterfaceBlock(const sh::InterfaceBlock &interfaceBlock)
{
   // Only 'packed' blocks are allowed to be considered inactive.
   return interfaceBlock.active || interfaceBlock.layout != sh::BLOCKLAYOUT_PACKED;
}

void WriteBlockMemberInfo(BinaryOutputStream *stream, const sh::BlockMemberInfo &var)
{
   stream->writeInt(var.arrayStride);
   stream->writeBool(var.isRowMajorMatrix);
   stream->writeInt(var.matrixStride);
   stream->writeInt(var.offset);
   stream->writeInt(var.topLevelArrayStride);
}

void LoadBlockMemberInfo(BinaryInputStream *stream, sh::BlockMemberInfo *var)
{
   var->arrayStride         = stream->readInt<int>();
   var->isRowMajorMatrix    = stream->readBool();
   var->matrixStride        = stream->readInt<int>();
   var->offset              = stream->readInt<int>();
   var->topLevelArrayStride = stream->readInt<int>();
}

void WriteShaderVar(BinaryOutputStream *stream, const sh::ShaderVariable &var)
{
   stream->writeInt(var.type);
   stream->writeInt(var.precision);
   stream->writeString(var.name);
   stream->writeString(var.mappedName);
   stream->writeIntVector(var.arraySizes);
   stream->writeBool(var.staticUse);
   stream->writeBool(var.active);
   stream->writeInt<size_t>(var.fields.size());
   for (const sh::ShaderVariable &shaderVariable : var.fields)
   {
       WriteShaderVar(stream, shaderVariable);
   }
   stream->writeString(var.structOrBlockName);
   stream->writeString(var.mappedStructOrBlockName);
   stream->writeBool(var.isRowMajorLayout);
   stream->writeInt(var.location);
   stream->writeBool(var.hasImplicitLocation);
   stream->writeInt(var.binding);
   stream->writeInt(var.imageUnitFormat);
   stream->writeInt(var.offset);
   stream->writeBool(var.rasterOrdered);
   stream->writeBool(var.readonly);
   stream->writeBool(var.writeonly);
   stream->writeBool(var.isFragmentInOut);
   stream->writeInt(var.index);
   stream->writeBool(var.yuv);
   stream->writeEnum(var.interpolation);
   stream->writeBool(var.isInvariant);
   stream->writeBool(var.isShaderIOBlock);
   stream->writeBool(var.isPatch);
   stream->writeBool(var.texelFetchStaticUse);
   stream->writeInt(var.getFlattenedOffsetInParentArrays());
}

void LoadShaderVar(gl::BinaryInputStream *stream, sh::ShaderVariable *var)
{
   var->type      = stream->readInt<GLenum>();
   var->precision = stream->readInt<GLenum>();
   stream->readString(&var->name);
   stream->readString(&var->mappedName);
   stream->readIntVector<unsigned int>(&var->arraySizes);
   var->staticUse      = stream->readBool();
   var->active         = stream->readBool();
   size_t elementCount = stream->readInt<size_t>();
   var->fields.resize(elementCount);
   for (sh::ShaderVariable &variable : var->fields)
   {
       LoadShaderVar(stream, &variable);
   }
   stream->readString(&var->structOrBlockName);
   stream->readString(&var->mappedStructOrBlockName);
   var->isRowMajorLayout    = stream->readBool();
   var->location            = stream->readInt<int>();
   var->hasImplicitLocation = stream->readBool();
   var->binding             = stream->readInt<int>();
   var->imageUnitFormat     = stream->readInt<GLenum>();
   var->offset              = stream->readInt<int>();
   var->rasterOrdered       = stream->readBool();
   var->readonly            = stream->readBool();
   var->writeonly           = stream->readBool();
   var->isFragmentInOut     = stream->readBool();
   var->index               = stream->readInt<int>();
   var->yuv                 = stream->readBool();
   var->interpolation       = stream->readEnum<sh::InterpolationType>();
   var->isInvariant         = stream->readBool();
   var->isShaderIOBlock     = stream->readBool();
   var->isPatch             = stream->readBool();
   var->texelFetchStaticUse = stream->readBool();
   var->setParentArrayIndex(stream->readInt<int>());
}

// VariableLocation implementation.
VariableLocation::VariableLocation() : arrayIndex(0), index(kUnused), ignored(false) {}

VariableLocation::VariableLocation(unsigned int arrayIndex, unsigned int index)
   : arrayIndex(arrayIndex), index(index), ignored(false)
{
   ASSERT(arrayIndex != GL_INVALID_INDEX);
}

// SamplerBindings implementation.
SamplerBinding::SamplerBinding(TextureType textureTypeIn,
                              GLenum samplerTypeIn,
                              SamplerFormat formatIn,
                              size_t elementCount)
   : textureType(textureTypeIn),
     samplerType(samplerTypeIn),
     format(formatIn),
     boundTextureUnits(elementCount, 0)
{}

SamplerBinding::SamplerBinding(const SamplerBinding &other) = default;

SamplerBinding::~SamplerBinding() = default;

// ProgramBindings implementation.
ProgramBindings::ProgramBindings() {}

ProgramBindings::~ProgramBindings() {}

void ProgramBindings::bindLocation(GLuint index, const std::string &name)
{
   mBindings[name] = index;
}

int ProgramBindings::getBindingByName(const std::string &name) const
{
   auto iter = mBindings.find(name);
   return (iter != mBindings.end()) ? iter->second : -1;
}

int ProgramBindings::getBinding(const sh::ShaderVariable &variable) const
{
   return getBindingByName(variable.name);
}

ProgramBindings::const_iterator ProgramBindings::begin() const
{
   return mBindings.begin();
}

ProgramBindings::const_iterator ProgramBindings::end() const
{
   return mBindings.end();
}

std::map<std::string, GLuint> ProgramBindings::getStableIterationMap() const
{
   return std::map<std::string, GLuint>(mBindings.begin(), mBindings.end());
}

// ProgramAliasedBindings implementation.
ProgramAliasedBindings::ProgramAliasedBindings() {}

ProgramAliasedBindings::~ProgramAliasedBindings() {}

void ProgramAliasedBindings::bindLocation(GLuint index, const std::string &name)
{
   mBindings[name] = ProgramBinding(index);

   // EXT_blend_func_extended spec: "If it specifies the base name of an array,
   // it identifies the resources associated with the first element of the array."
   //
   // Normalize array bindings so that "name" and "name[0]" map to the same entry.
   // If this binding is of the form "name[0]", then mark the "name" binding as
   // aliased but do not update it yet in case "name" is not actually an array.
   size_t nameLengthWithoutArrayIndex;
   unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex);
   if (arrayIndex == 0)
   {
       std::string baseName = name.substr(0u, nameLengthWithoutArrayIndex);
       auto iter            = mBindings.find(baseName);
       if (iter != mBindings.end())
       {
           iter->second.aliased = true;
       }
   }
}

int ProgramAliasedBindings::getBindingByName(const std::string &name) const
{
   auto iter = mBindings.find(name);
   return (iter != mBindings.end()) ? iter->second.location : -1;
}

int ProgramAliasedBindings::getBindingByLocation(GLuint location) const
{
   for (const auto &iter : mBindings)
   {
       if (iter.second.location == location)
       {
           return iter.second.location;
       }
   }
   return -1;
}

int ProgramAliasedBindings::getBinding(const sh::ShaderVariable &variable) const
{
   const std::string &name = variable.name;

   // Check with the normalized array name if applicable.
   if (variable.isArray())
   {
       size_t nameLengthWithoutArrayIndex;
       unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex);
       if (arrayIndex == 0)
       {
           std::string baseName = name.substr(0u, nameLengthWithoutArrayIndex);
           auto iter            = mBindings.find(baseName);
           // If "name" exists and is not aliased, that means it was modified more
           // recently than its "name[0]" form and should be used instead of that.
           if (iter != mBindings.end() && !iter->second.aliased)
           {
               return iter->second.location;
           }
       }
       else if (arrayIndex == GL_INVALID_INDEX)
       {
           auto iter = mBindings.find(variable.name);
           // If "name" exists and is not aliased, that means it was modified more
           // recently than its "name[0]" form and should be used instead of that.
           if (iter != mBindings.end() && !iter->second.aliased)
           {
               return iter->second.location;
           }
           // The base name was aliased, so use the name with the array notation.
           return getBindingByName(name + "[0]");
       }
   }

   return getBindingByName(name);
}

ProgramAliasedBindings::const_iterator ProgramAliasedBindings::begin() const
{
   return mBindings.begin();
}

ProgramAliasedBindings::const_iterator ProgramAliasedBindings::end() const
{
   return mBindings.end();
}

std::map<std::string, ProgramBinding> ProgramAliasedBindings::getStableIterationMap() const
{
   return std::map<std::string, ProgramBinding>(mBindings.begin(), mBindings.end());
}

// ImageBinding implementation.
ImageBinding::ImageBinding(size_t count, TextureType textureTypeIn)
   : textureType(textureTypeIn), boundImageUnits(count, 0)
{}
ImageBinding::ImageBinding(GLuint imageUnit, size_t count, TextureType textureTypeIn)
   : textureType(textureTypeIn)
{
   for (size_t index = 0; index < count; ++index)
   {
       boundImageUnits.push_back(imageUnit + static_cast<GLuint>(index));
   }
}

ImageBinding::ImageBinding(const ImageBinding &other) = default;

ImageBinding::~ImageBinding() = default;

// ProgramState implementation.
ProgramState::ProgramState()
   : mLabel(),
     mAttachedShaders{},
     mLocationsUsedForXfbExtension(0),
     mBinaryRetrieveableHint(false),
     mSeparable(false),
     mNumViews(-1),
     mDrawIDLocation(-1),
     mBaseVertexLocation(-1),
     mBaseInstanceLocation(-1),
     mCachedBaseVertex(0),
     mCachedBaseInstance(0),
     mExecutable(new ProgramExecutable())
{
   mComputeShaderLocalSize.fill(1);
}

ProgramState::~ProgramState()
{
   ASSERT(!hasAttachedShader());
}

const std::string &ProgramState::getLabel()
{
   return mLabel;
}

Shader *ProgramState::getAttachedShader(ShaderType shaderType) const
{
   ASSERT(shaderType != ShaderType::InvalidEnum);
   return mAttachedShaders[shaderType];
}

GLuint ProgramState::getUniformIndexFromName(const std::string &name) const
{
   return GetResourceIndexFromName(mExecutable->mUniforms, name);
}

GLuint ProgramState::getBufferVariableIndexFromName(const std::string &name) const
{
   return GetResourceIndexFromName(mBufferVariables, name);
}

GLuint ProgramState::getUniformIndexFromLocation(UniformLocation location) const
{
   ASSERT(location.value >= 0 && static_cast<size_t>(location.value) < mUniformLocations.size());
   return mUniformLocations[location.value].index;
}

Optional<GLuint> ProgramState::getSamplerIndex(UniformLocation location) const
{
   GLuint index = getUniformIndexFromLocation(location);
   if (!isSamplerUniformIndex(index))
   {
       return Optional<GLuint>::Invalid();
   }

   return getSamplerIndexFromUniformIndex(index);
}

bool ProgramState::isSamplerUniformIndex(GLuint index) const
{
   return mExecutable->mSamplerUniformRange.contains(index);
}

GLuint ProgramState::getSamplerIndexFromUniformIndex(GLuint uniformIndex) const
{
   ASSERT(isSamplerUniformIndex(uniformIndex));
   return uniformIndex - mExecutable->mSamplerUniformRange.low();
}

GLuint ProgramState::getUniformIndexFromSamplerIndex(GLuint samplerIndex) const
{
   return mExecutable->getUniformIndexFromSamplerIndex(samplerIndex);
}

bool ProgramState::isImageUniformIndex(GLuint index) const
{
   return mExecutable->mImageUniformRange.contains(index);
}

GLuint ProgramState::getImageIndexFromUniformIndex(GLuint uniformIndex) const
{
   ASSERT(isImageUniformIndex(uniformIndex));
   return uniformIndex - mExecutable->mImageUniformRange.low();
}

GLuint ProgramState::getAttributeLocation(const std::string &name) const
{
   for (const sh::ShaderVariable &attribute : mExecutable->mProgramInputs)
   {
       if (attribute.name == name)
       {
           return attribute.location;
       }
   }

   return static_cast<GLuint>(-1);
}

bool ProgramState::hasAttachedShader() const
{
   for (const Shader *shader : mAttachedShaders)
   {
       if (shader)
       {
           return true;
       }
   }
   return false;
}

ShaderType ProgramState::getFirstAttachedShaderStageType() const
{
   const ShaderBitSet linkedStages = mExecutable->getLinkedShaderStages();
   if (linkedStages.none())
   {
       return ShaderType::InvalidEnum;
   }

   return linkedStages.first();
}

ShaderType ProgramState::getLastAttachedShaderStageType() const
{
   const ShaderBitSet linkedStages = mExecutable->getLinkedShaderStages();
   if (linkedStages.none())
   {
       return ShaderType::InvalidEnum;
   }

   return linkedStages.last();
}

ShaderType ProgramState::getAttachedTransformFeedbackStage() const
{
   if (mAttachedShaders[ShaderType::Geometry])
   {
       return ShaderType::Geometry;
   }
   if (mAttachedShaders[ShaderType::TessEvaluation])
   {
       return ShaderType::TessEvaluation;
   }
   return ShaderType::Vertex;
}

Program::Program(rx::GLImplFactory *factory, ShaderProgramManager *manager, ShaderProgramID handle)
   : mSerial(factory->generateSerial()),
     mProgram(factory->createProgram(mState)),
     mValidated(false),
     mLinked(false),
     mDeleteStatus(false),
     mRefCount(0),
     mResourceManager(manager),
     mHandle(handle)
{
   ASSERT(mProgram);

   unlink();
}

Program::~Program()
{
   ASSERT(!mProgram);
}

void Program::onDestroy(const Context *context)
{
   resolveLink(context);
   for (ShaderType shaderType : AllShaderTypes())
   {
       if (mState.mAttachedShaders[shaderType])
       {
           mState.mAttachedShaders[shaderType]->release(context);
           mState.mAttachedShaders[shaderType] = nullptr;
       }
   }

   mProgram->destroy(context);

   ASSERT(!mState.hasAttachedShader());
   SafeDelete(mProgram);

   delete this;
}
ShaderProgramID Program::id() const
{
   ASSERT(!mLinkingState);
   return mHandle;
}

angle::Result Program::setLabel(const Context *context, const std::string &label)
{
   ASSERT(!mLinkingState);
   mState.mLabel = label;

   if (mProgram)
   {
       return mProgram->onLabelUpdate(context);
   }
   return angle::Result::Continue;
}

const std::string &Program::getLabel() const
{
   ASSERT(!mLinkingState);
   return mState.mLabel;
}

void Program::attachShader(Shader *shader)
{
   ShaderType shaderType = shader->getType();
   ASSERT(shaderType != ShaderType::InvalidEnum);

   mState.mAttachedShaders[shaderType] = shader;
   mState.mAttachedShaders[shaderType]->addRef();
}

void Program::detachShader(const Context *context, Shader *shader)
{
   resolveLink(context);
   ShaderType shaderType = shader->getType();
   ASSERT(shaderType != ShaderType::InvalidEnum);

   ASSERT(mState.mAttachedShaders[shaderType] == shader);
   shader->release(context);
   mState.mAttachedShaders[shaderType] = nullptr;
}

int Program::getAttachedShadersCount() const
{
   ASSERT(!mLinkingState);
   int numAttachedShaders = 0;
   for (const Shader *shader : mState.mAttachedShaders)
   {
       if (shader)
       {
           ++numAttachedShaders;
       }
   }

   return numAttachedShaders;
}

Shader *Program::getAttachedShader(ShaderType shaderType) const
{
   ASSERT(!mLinkingState);
   return mState.getAttachedShader(shaderType);
}

void Program::bindAttributeLocation(GLuint index, const char *name)
{
   ASSERT(!mLinkingState);
   mAttributeBindings.bindLocation(index, name);
}

void Program::bindUniformLocation(UniformLocation location, const char *name)
{
   ASSERT(!mLinkingState);
   mState.mUniformLocationBindings.bindLocation(location.value, name);
}

void Program::bindFragmentOutputLocation(GLuint index, const char *name)
{
   mFragmentOutputLocations.bindLocation(index, name);
}

void Program::bindFragmentOutputIndex(GLuint index, const char *name)
{
   mFragmentOutputIndexes.bindLocation(index, name);
}

angle::Result Program::link(const Context *context)
{
   angle::Result result = linkImpl(context);

   // Avoid having two ProgramExecutables if the link failed and the Program had successfully
   // linked previously.
   if (mLinkingState && mLinkingState->linkedExecutable)
   {
       mState.mExecutable = mLinkingState->linkedExecutable;
   }

   return result;
}

// The attached shaders are checked for linking errors by matching up their variables.
// Uniform, input and output variables get collected.
// The code gets compiled into binaries.
angle::Result Program::linkImpl(const Context *context)
{
   ASSERT(!mLinkingState);
   // Don't make any local variables pointing to anything within the ProgramExecutable, since
   // unlink() could make a new ProgramExecutable making any references/pointers invalid.
   auto *platform   = ANGLEPlatformCurrent();
   double startTime = platform->currentTime(platform);

   // Unlink the program, but do not clear the validation-related caching yet, since we can still
   // use the previously linked program if linking the shaders fails.
   mLinked = false;

   mState.mExecutable->resetInfoLog();

   // Validate we have properly attached shaders before checking the cache.
   if (!linkValidateShaders(context, mState.mExecutable->getInfoLog()))
   {
       return angle::Result::Continue;
   }

   egl::BlobCache::Key programHash = {0};
   MemoryProgramCache *cache       = context->getMemoryProgramCache();

   // TODO: http://anglebug.com/4530: Enable program caching for separable programs
   if (cache && !isSeparable())
   {
       std::lock_guard<std::mutex> cacheLock(context->getProgramCacheMutex());
       angle::Result cacheResult = cache->getProgram(context, this, &programHash);
       ANGLE_TRY(cacheResult);

       // Check explicitly for Continue, Incomplete means a cache miss
       if (cacheResult == angle::Result::Continue)
       {
           std::scoped_lock lock(mHistogramMutex);
           // Succeeded in loading the binaries in the front-end, back end may still be loading
           // asynchronously
           double delta = platform->currentTime(platform) - startTime;
           int us       = static_cast<int>(delta * 1000000.0);
           ANGLE_HISTOGRAM_COUNTS("GPU.ANGLE.ProgramCache.ProgramCacheHitTimeUS", us);
           return angle::Result::Continue;
       }
   }

   // Cache load failed, fall through to normal linking.
   unlink();
   InfoLog &infoLog = mState.mExecutable->getInfoLog();

   // Re-link shaders after the unlink call.
   bool result = linkValidateShaders(context, infoLog);
   ASSERT(result);

   std::unique_ptr<LinkingState> linkingState(new LinkingState());
   ProgramMergedVaryings mergedVaryings;
   LinkingVariables linkingVariables(context, mState);
   ProgramLinkedResources &resources = linkingState->resources;

   resources.init(&mState.mExecutable->mUniformBlocks, &mState.mExecutable->mUniforms,
                  &mState.mExecutable->mShaderStorageBlocks, &mState.mBufferVariables,
                  &mState.mExecutable->mAtomicCounterBuffers);

   // TODO: Fix incomplete linking. http://anglebug.com/6358
   updateLinkedShaderStages();

   InitUniformBlockLinker(context, mState, &resources.uniformBlockLinker);
   InitShaderStorageBlockLinker(context, mState, &resources.shaderStorageBlockLinker);

   if (mState.mAttachedShaders[ShaderType::Compute])
   {
       GLuint combinedImageUniforms = 0;
       if (!linkUniforms(context, &resources.unusedUniforms, &combinedImageUniforms, infoLog))
       {
           return angle::Result::Continue;
       }

       GLuint combinedShaderStorageBlocks = 0u;
       if (!LinkValidateProgramInterfaceBlocks(context,
                                               mState.mExecutable->getLinkedShaderStages(),
                                               resources, infoLog, &combinedShaderStorageBlocks))
       {
           return angle::Result::Continue;
       }

       // [OpenGL ES 3.1] Chapter 8.22 Page 203:
       // A link error will be generated if the sum of the number of active image uniforms used in
       // all shaders, the number of active shader storage blocks, and the number of active
       // fragment shader outputs exceeds the implementation-dependent value of
       // MAX_COMBINED_SHADER_OUTPUT_RESOURCES.
       if (combinedImageUniforms + combinedShaderStorageBlocks >
           static_cast<GLuint>(context->getCaps().maxCombinedShaderOutputResources))
       {
           infoLog
               << "The sum of the number of active image uniforms, active shader storage blocks "
                  "and active fragment shader outputs exceeds "
                  "MAX_COMBINED_SHADER_OUTPUT_RESOURCES ("
               << context->getCaps().maxCombinedShaderOutputResources << ")";
           return angle::Result::Continue;
       }
   }
   else
   {
       if (!linkAttributes(context, infoLog))
       {
           return angle::Result::Continue;
       }

       if (!linkVaryings(context, infoLog))
       {
           return angle::Result::Continue;
       }

       GLuint combinedImageUniforms = 0;
       if (!linkUniforms(context, &resources.unusedUniforms, &combinedImageUniforms, infoLog))
       {
           return angle::Result::Continue;
       }

       GLuint combinedShaderStorageBlocks = 0u;
       if (!LinkValidateProgramInterfaceBlocks(context,
                                               mState.mExecutable->getLinkedShaderStages(),
                                               resources, infoLog, &combinedShaderStorageBlocks))
       {
           return angle::Result::Continue;
       }

       if (!LinkValidateProgramGlobalNames(infoLog, getExecutable(), linkingVariables))
       {
           return angle::Result::Continue;
       }

       gl::Shader *vertexShader = mState.mAttachedShaders[ShaderType::Vertex];
       if (vertexShader)
       {
           mState.mNumViews = vertexShader->getNumViews(context);
           mState.mSpecConstUsageBits |= vertexShader->getSpecConstUsageBits();
       }

       gl::Shader *fragmentShader = mState.mAttachedShaders[ShaderType::Fragment];
       if (fragmentShader)
       {
           if (!mState.mExecutable->linkValidateOutputVariables(
                   context->getCaps(), context->getExtensions(), context->getClientVersion(),
                   combinedImageUniforms, combinedShaderStorageBlocks,
                   fragmentShader->getActiveOutputVariables(context),
                   fragmentShader->getShaderVersion(context), mFragmentOutputLocations,
                   mFragmentOutputIndexes))
           {
               return angle::Result::Continue;
           }

           mState.mExecutable->mHasDiscard = fragmentShader->hasDiscard();
           mState.mExecutable->mEnablesPerSampleShading =
               fragmentShader->enablesPerSampleShading();
           mState.mExecutable->mAdvancedBlendEquations =
               fragmentShader->getAdvancedBlendEquations();
           mState.mSpecConstUsageBits |= fragmentShader->getSpecConstUsageBits();
       }

       mergedVaryings = GetMergedVaryingsFromLinkingVariables(linkingVariables);
       if (!mState.mExecutable->linkMergedVaryings(
               context, mergedVaryings, mState.mTransformFeedbackVaryingNames, linkingVariables,
               isSeparable(), &resources.varyingPacking))
       {
           return angle::Result::Continue;
       }
   }

   mState.mExecutable->saveLinkedStateInfo(context, mState);

   mLinkingState                    = std::move(linkingState);
   mLinkingState->linkingFromBinary = false;
   mLinkingState->programHash       = programHash;
   mLinkingState->linkEvent         = mProgram->link(context, resources, infoLog, mergedVaryings);

   // Must be after mProgram->link() to avoid misleading the linker about output variables.
   mState.updateProgramInterfaceInputs(context);
   mState.updateProgramInterfaceOutputs(context);

   if (mState.mSeparable)
   {
       mLinkingState->linkedExecutable = mState.mExecutable;
   }

   return angle::Result::Continue;
}

bool Program::isLinking() const
{
   return (mLinkingState.get() && mLinkingState->linkEvent &&
           mLinkingState->linkEvent->isLinking());
}

void Program::resolveLinkImpl(const Context *context)
{
   ASSERT(mLinkingState.get());

   angle::Result result = mLinkingState->linkEvent->wait(context);

   mLinked                                    = result == angle::Result::Continue;
   std::unique_ptr<LinkingState> linkingState = std::move(mLinkingState);
   if (!mLinked)
   {
       mState.mExecutable->reset(false);
       return;
   }

   if (linkingState->linkingFromBinary)
   {
       // All internal Program state is already loaded from the binary.
       return;
   }

   initInterfaceBlockBindings();

   // According to GLES 3.0/3.1 spec for LinkProgram and UseProgram,
   // Only successfully linked program can replace the executables.
   ASSERT(mLinked);

   // Mark implementation-specific unreferenced uniforms as ignored.
   std::vector<ImageBinding> *imageBindings = getExecutable().getImageBindings();
   mProgram->markUnusedUniformLocations(&mState.mUniformLocations,
                                        &mState.mExecutable->mSamplerBindings, imageBindings);

   // Must be called after markUnusedUniformLocations.
   postResolveLink(context);

   // Save to the program cache.
   std::lock_guard<std::mutex> cacheLock(context->getProgramCacheMutex());
   MemoryProgramCache *cache = context->getMemoryProgramCache();
   // TODO: http://anglebug.com/4530: Enable program caching for separable programs
   if (cache && !isSeparable() &&
       (mState.mExecutable->mLinkedTransformFeedbackVaryings.empty() ||
        !context->getFrontendFeatures().disableProgramCachingForTransformFeedback.enabled))
   {
       if (cache->putProgram(linkingState->programHash, context, this) == angle::Result::Stop)
       {
           // Don't fail linking if putting the program binary into the cache fails, the program is
           // still usable.
           ANGLE_PERF_WARNING(context->getState().getDebug(), GL_DEBUG_SEVERITY_LOW,
                              "Failed to save linked program to memory program cache.");
       }
   }
}

void Program::updateLinkedShaderStages()
{
   mState.mExecutable->resetLinkedShaderStages();

   for (const Shader *shader : mState.mAttachedShaders)
   {
       if (shader)
       {
           mState.mExecutable->setLinkedShaderStages(shader->getType());
       }
   }
}

void ProgramState::updateActiveSamplers()
{
   mExecutable->mActiveSamplerRefCounts.fill(0);
   mExecutable->updateActiveSamplers(*this);
}

void ProgramState::updateProgramInterfaceInputs(const Context *context)
{
   const ShaderType firstAttachedShaderType = getFirstAttachedShaderStageType();

   if (firstAttachedShaderType == ShaderType::Vertex)
   {
       // Vertex attributes are already what we need, so nothing to do
       return;
   }

   Shader *shader = getAttachedShader(firstAttachedShaderType);
   ASSERT(shader);

   // Copy over each input varying, since the Shader could go away
   if (shader->getType() == ShaderType::Compute)
   {
       for (const sh::ShaderVariable &attribute : shader->getAllAttributes(context))
       {
           // Compute Shaders have the following built-in input variables.
           //
           // in uvec3 gl_NumWorkGroups;
           // in uvec3 gl_WorkGroupID;
           // in uvec3 gl_LocalInvocationID;
           // in uvec3 gl_GlobalInvocationID;
           // in uint  gl_LocalInvocationIndex;
           // They are all vecs or uints, so no special handling is required.
           mExecutable->mProgramInputs.emplace_back(attribute);
       }
   }
   else
   {
       for (const sh::ShaderVariable &varying : shader->getInputVaryings(context))
       {
           UpdateInterfaceVariable(&mExecutable->mProgramInputs, varying);
       }
   }
}

void ProgramState::updateProgramInterfaceOutputs(const Context *context)
{
   const ShaderType lastAttachedShaderType = getLastAttachedShaderStageType();

   if (lastAttachedShaderType == ShaderType::Fragment)
   {
       // Fragment outputs are already what we need, so nothing to do
       return;
   }
   if (lastAttachedShaderType == ShaderType::Compute)
   {
       // If the program only contains a Compute Shader, then there are no user-defined outputs.
       return;
   }

   Shader *shader = getAttachedShader(lastAttachedShaderType);
   ASSERT(shader);

   // Copy over each output varying, since the Shader could go away
   for (const sh::ShaderVariable &varying : shader->getOutputVaryings(context))
   {
       UpdateInterfaceVariable(&mExecutable->mOutputVariables, varying);
   }
}

// Returns the program object to an unlinked state, before re-linking, or at destruction
void Program::unlink()
{
   if (mLinkingState && mLinkingState->linkedExecutable)
   {
       // The new ProgramExecutable that we'll attempt to link with needs to start from a copy of
       // the last successfully linked ProgramExecutable, so we don't lose any state information.
       mState.mExecutable.reset(new ProgramExecutable(*mLinkingState->linkedExecutable));
   }
   mState.mExecutable->reset(true);

   mState.mUniformLocations.clear();
   mState.mBufferVariables.clear();
   mState.mComputeShaderLocalSize.fill(1);
   mState.mNumViews             = -1;
   mState.mDrawIDLocation       = -1;
   mState.mBaseVertexLocation   = -1;
   mState.mBaseInstanceLocation = -1;
   mState.mCachedBaseVertex     = 0;
   mState.mCachedBaseInstance   = 0;
   mState.mSpecConstUsageBits.reset();

   mValidated = false;

   mLinked = false;
}

angle::Result Program::loadBinary(const Context *context,
                                 GLenum binaryFormat,
                                 const void *binary,
                                 GLsizei length)
{
   ASSERT(!mLinkingState);
   unlink();
   InfoLog &infoLog = mState.mExecutable->getInfoLog();

   if (!angle::GetANGLEHasBinaryLoading())
   {
       return angle::Result::Incomplete;
   }

   ASSERT(binaryFormat == GL_PROGRAM_BINARY_ANGLE);
   if (binaryFormat != GL_PROGRAM_BINARY_ANGLE)
   {
       infoLog << "Invalid program binary format.";
       return angle::Result::Incomplete;
   }

   BinaryInputStream stream(binary, length);
   ANGLE_TRY(deserialize(context, stream, infoLog));
   // Currently we require the full shader text to compute the program hash.
   // We could also store the binary in the internal program cache.

   for (size_t uniformBlockIndex = 0;
        uniformBlockIndex < mState.mExecutable->getActiveUniformBlockCount(); ++uniformBlockIndex)
   {
       mDirtyBits.set(uniformBlockIndex);
   }

   // The rx::LinkEvent returned from ProgramImpl::load is a base class with multiple
   // implementations. In some implementations, a background thread is used to compile the
   // shaders. Any calls to the LinkEvent object, therefore, are racy and may interfere with
   // the operation.

   // We do not want to call LinkEvent::wait because that will cause the background thread
   // to finish its task before returning, thus defeating the purpose of background compilation.
   // We need to defer waiting on background compilation until the very last minute when we
   // absolutely need the results, such as when the developer binds the program or queries
   // for the completion status.

   // If load returns nullptr, we know for sure that the binary is not compatible with the backend.
   // The loaded binary could have been read from the on-disk shader cache and be corrupted or
   // serialized with different revision and subsystem id than the currently loaded backend.
   // Returning 'Incomplete' to the caller results in link happening using the original shader
   // sources.
   angle::Result result;
   std::unique_ptr<LinkingState> linkingState;
   std::unique_ptr<rx::LinkEvent> linkEvent = mProgram->load(context, &stream, infoLog);
   if (linkEvent)
   {
       linkingState                    = std::make_unique<LinkingState>();
       linkingState->linkingFromBinary = true;
       linkingState->linkEvent         = std::move(linkEvent);
       result                          = angle::Result::Continue;
   }
   else
   {
       result = angle::Result::Incomplete;
   }
   mLinkingState = std::move(linkingState);

   return result;
}

angle::Result Program::saveBinary(Context *context,
                                 GLenum *binaryFormat,
                                 void *binary,
                                 GLsizei bufSize,
                                 GLsizei *length) const
{
   ASSERT(!mLinkingState);
   if (binaryFormat)
   {
       *binaryFormat = GL_PROGRAM_BINARY_ANGLE;
   }

   angle::MemoryBuffer memoryBuf;
   ANGLE_TRY(serialize(context, &memoryBuf));

   GLsizei streamLength       = static_cast<GLsizei>(memoryBuf.size());
   const uint8_t *streamState = memoryBuf.data();

   if (streamLength > bufSize)
   {
       if (length)
       {
           *length = 0;
       }

       // TODO: This should be moved to the validation layer but computing the size of the binary
       // before saving it causes the save to happen twice.  It may be possible to write the binary
       // to a separate buffer, validate sizes and then copy it.
       ANGLE_CHECK(context, false, "Insufficient buffer size", GL_INVALID_OPERATION);
   }

   if (binary)
   {
       char *ptr = reinterpret_cast<char *>(binary);

       memcpy(ptr, streamState, streamLength);
       ptr += streamLength;

       ASSERT(ptr - streamLength == binary);
   }

   if (length)
   {
       *length = streamLength;
   }

   return angle::Result::Continue;
}

GLint Program::getBinaryLength(Context *context) const
{
   ASSERT(!mLinkingState);
   if (!mLinked)
   {
       return 0;
   }

   GLint length;
   angle::Result result =
       saveBinary(context, nullptr, nullptr, std::numeric_limits<GLint>::max(), &length);
   if (result != angle::Result::Continue)
   {
       return 0;
   }

   return length;
}

void Program::setBinaryRetrievableHint(bool retrievable)
{
   ASSERT(!mLinkingState);
   // TODO(jmadill) : replace with dirty bits
   mProgram->setBinaryRetrievableHint(retrievable);
   mState.mBinaryRetrieveableHint = retrievable;
}

bool Program::getBinaryRetrievableHint() const
{
   ASSERT(!mLinkingState);
   return mState.mBinaryRetrieveableHint;
}

void Program::setSeparable(bool separable)
{
   ASSERT(!mLinkingState);
   // TODO(yunchao) : replace with dirty bits
   if (mState.mSeparable != separable)
   {
       mProgram->setSeparable(separable);
       mState.mSeparable = separable;
   }
}

bool Program::isSeparable() const
{
   ASSERT(!mLinkingState);
   return mState.mSeparable;
}

void Program::deleteSelf(const Context *context)
{
   ASSERT(mRefCount == 0 && mDeleteStatus);
   mResourceManager->deleteProgram(context, mHandle);
}

unsigned int Program::getRefCount() const
{
   return mRefCount;
}

void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, ShaderProgramID *shaders) const
{
   ASSERT(!mLinkingState);
   int total = 0;

   for (const Shader *shader : mState.mAttachedShaders)
   {
       if (shader && (total < maxCount))
       {
           shaders[total] = shader->getHandle();
           ++total;
       }
   }

   if (count)
   {
       *count = total;
   }
}

GLuint Program::getAttributeLocation(const std::string &name) const
{
   ASSERT(!mLinkingState);
   return mState.getAttributeLocation(name);
}

void Program::getActiveAttribute(GLuint index,
                                GLsizei bufsize,
                                GLsizei *length,
                                GLint *size,
                                GLenum *type,
                                GLchar *name) const
{
   ASSERT(!mLinkingState);
   if (!mLinked)
   {
       if (bufsize > 0)
       {
           name[0] = '\0';
       }

       if (length)
       {
           *length = 0;
       }

       *type = GL_NONE;
       *size = 1;
       return;
   }

   ASSERT(index < mState.mExecutable->getProgramInputs().size());
   const sh::ShaderVariable &attrib = mState.mExecutable->getProgramInputs()[index];

   if (bufsize > 0)
   {
       CopyStringToBuffer(name, attrib.name, bufsize, length);
   }

   // Always a single 'type' instance
   *size = 1;
   *type = attrib.type;
}

GLint Program::getActiveAttributeCount() const
{
   ASSERT(!mLinkingState);
   if (!mLinked)
   {
       return 0;
   }

   return static_cast<GLint>(mState.mExecutable->getProgramInputs().size());
}

GLint Program::getActiveAttributeMaxLength() const
{
   ASSERT(!mLinkingState);
   if (!mLinked)
   {
       return 0;
   }

   size_t maxLength = 0;

   for (const sh::ShaderVariable &attrib : mState.mExecutable->getProgramInputs())
   {
       maxLength = std::max(attrib.name.length() + 1, maxLength);
   }

   return static_cast<GLint>(maxLength);
}

const std::vector<sh::ShaderVariable> &Program::getAttributes() const
{
   ASSERT(!mLinkingState);
   return mState.mExecutable->getProgramInputs();
}

const sh::WorkGroupSize &Program::getComputeShaderLocalSize() const
{
   ASSERT(!mLinkingState);
   return mState.mComputeShaderLocalSize;
}

PrimitiveMode Program::getGeometryShaderInputPrimitiveType() const
{
   ASSERT(!mLinkingState && mState.mExecutable);
   return mState.mExecutable->getGeometryShaderInputPrimitiveType();
}
PrimitiveMode Program::getGeometryShaderOutputPrimitiveType() const
{
   ASSERT(!mLinkingState && mState.mExecutable);
   return mState.mExecutable->getGeometryShaderOutputPrimitiveType();
}
GLint Program::getGeometryShaderInvocations() const
{
   ASSERT(!mLinkingState && mState.mExecutable);
   return mState.mExecutable->getGeometryShaderInvocations();
}
GLint Program::getGeometryShaderMaxVertices() const
{
   ASSERT(!mLinkingState && mState.mExecutable);
   return mState.mExecutable->getGeometryShaderMaxVertices();
}

GLint Program::getTessControlShaderVertices() const
{
   ASSERT(!mLinkingState && mState.mExecutable);
   return mState.mExecutable->mTessControlShaderVertices;
}

GLenum Program::getTessGenMode() const
{
   ASSERT(!mLinkingState && mState.mExecutable);
   return mState.mExecutable->mTessGenMode;
}

GLenum Program::getTessGenPointMode() const
{
   ASSERT(!mLinkingState && mState.mExecutable);
   return mState.mExecutable->mTessGenPointMode;
}

GLenum Program::getTessGenSpacing() const
{
   ASSERT(!mLinkingState && mState.mExecutable);
   return mState.mExecutable->mTessGenSpacing;
}

GLenum Program::getTessGenVertexOrder() const
{
   ASSERT(!mLinkingState && mState.mExecutable);
   return mState.mExecutable->mTessGenVertexOrder;
}

const sh::ShaderVariable &Program::getInputResource(size_t index) const
{
   ASSERT(!mLinkingState);
   ASSERT(index < mState.mExecutable->getProgramInputs().size());
   return mState.mExecutable->getProgramInputs()[index];
}

GLuint Program::getInputResourceIndex(const GLchar *name) const
{
   ASSERT(!mLinkingState);
   const std::string nameString = StripLastArrayIndex(name);

   for (size_t index = 0; index < mState.mExecutable->getProgramInputs().size(); index++)
   {
       sh::ShaderVariable resource = getInputResource(index);
       if (resource.name == nameString)
       {
           return static_cast<GLuint>(index);
       }
   }

   return GL_INVALID_INDEX;
}

GLuint Program::getResourceMaxNameSize(const sh::ShaderVariable &resource, GLint max) const
{
   if (resource.isArray())
   {
       return std::max(max, clampCast<GLint>((resource.name + "[0]").size()));
   }
   else
   {
       return std::max(max, clampCast<GLint>((resource.name).size()));
   }
}

GLuint Program::getInputResourceMaxNameSize() const
{
   GLint max = 0;

   for (const sh::ShaderVariable &resource : mState.mExecutable->getProgramInputs())
   {
       max = getResourceMaxNameSize(resource, max);
   }

   return max;
}

GLuint Program::getOutputResourceMaxNameSize() const
{
   GLint max = 0;

   for (const sh::ShaderVariable &resource : mState.mExecutable->getOutputVariables())
   {
       max = getResourceMaxNameSize(resource, max);
   }

   return max;
}

GLuint Program::getResourceLocation(const GLchar *name, const sh::ShaderVariable &variable) const
{
   if (variable.isBuiltIn())
   {
       return GL_INVALID_INDEX;
   }

   GLint location = variable.location;
   if (variable.isArray())
   {
       size_t nameLengthWithoutArrayIndexOut;
       size_t arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndexOut);
       // The 'name' string may not contain the array notation "[0]"
       if (arrayIndex != GL_INVALID_INDEX)
       {
           location += arrayIndex;
       }
   }

   return location;
}

GLuint Program::getInputResourceLocation(const GLchar *name) const
{
   const GLuint index = getInputResourceIndex(name);
   if (index == GL_INVALID_INDEX)
   {
       return index;
   }

   const sh::ShaderVariable &variable = getInputResource(index);

   return getResourceLocation(name, variable);
}

GLuint Program::getOutputResourceLocation(const GLchar *name) const
{
   const GLuint index = getOutputResourceIndex(name);
   if (index == GL_INVALID_INDEX)
   {
       return index;
   }

   const sh::ShaderVariable &variable = getOutputResource(index);

   return getResourceLocation(name, variable);
}

GLuint Program::getOutputResourceIndex(const GLchar *name) const
{
   ASSERT(!mLinkingState);
   const std::string nameString = StripLastArrayIndex(name);

   for (size_t index = 0; index < mState.mExecutable->getOutputVariables().size(); index++)
   {
       sh::ShaderVariable resource = getOutputResource(index);
       if (resource.name == nameString)
       {
           return static_cast<GLuint>(index);
       }
   }

   return GL_INVALID_INDEX;
}

size_t Program::getOutputResourceCount() const
{
   ASSERT(!mLinkingState);
   return (mLinked ? mState.mExecutable->getOutputVariables().size() : 0);
}

void Program::getResourceName(const std::string name,
                             GLsizei bufSize,
                             GLsizei *length,
                             GLchar *dest) const
{
   if (length)
   {
       *length = 0;
   }

   if (!mLinked)
   {
       if (bufSize > 0)
       {
           dest[0] = '\0';
       }
       return;
   }

   if (bufSize > 0)
   {
       CopyStringToBuffer(dest, name, bufSize, length);
   }
}

void Program::getInputResourceName(GLuint index,
                                  GLsizei bufSize,
                                  GLsizei *length,
                                  GLchar *name) const
{
   ASSERT(!mLinkingState);
   getResourceName(getInputResourceName(index), bufSize, length, name);
}

void Program::getOutputResourceName(GLuint index,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLchar *name) const
{
   ASSERT(!mLinkingState);
   getResourceName(getOutputResourceName(index), bufSize, length, name);
}

void Program::getUniformResourceName(GLuint index,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLchar *name) const
{
   ASSERT(!mLinkingState);
   ASSERT(index < mState.mExecutable->getUniforms().size());
   getResourceName(mState.mExecutable->getUniforms()[index].name, bufSize, length, name);
}

void Program::getBufferVariableResourceName(GLuint index,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLchar *name) const
{
   ASSERT(!mLinkingState);
   ASSERT(index < mState.mBufferVariables.size());
   getResourceName(mState.mBufferVariables[index].name, bufSize, length, name);
}

const std::string Program::getResourceName(const sh::ShaderVariable &resource) const
{
   std::string resourceName = resource.name;

   if (resource.isArray())
   {
       resourceName += "[0]";
   }

   return resourceName;
}

const std::string Program::getInputResourceName(GLuint index) const
{
   ASSERT(!mLinkingState);
   const sh::ShaderVariable &resource = getInputResource(index);

   return getResourceName(resource);
}

const std::string Program::getOutputResourceName(GLuint index) const
{
   ASSERT(!mLinkingState);
   const sh::ShaderVariable &resource = getOutputResource(index);

   return getResourceName(resource);
}

const sh::ShaderVariable &Program::getOutputResource(size_t index) const
{
   ASSERT(!mLinkingState);
   ASSERT(index < mState.mExecutable->getOutputVariables().size());
   return mState.mExecutable->getOutputVariables()[index];
}

const ProgramBindings &Program::getAttributeBindings() const
{
   ASSERT(!mLinkingState);
   return mAttributeBindings;
}
const ProgramAliasedBindings &Program::getUniformLocationBindings() const
{
   ASSERT(!mLinkingState);
   return mState.mUniformLocationBindings;
}

const gl::ProgramAliasedBindings &Program::getFragmentOutputLocations() const
{
   ASSERT(!mLinkingState);
   return mFragmentOutputLocations;
}

const gl::ProgramAliasedBindings &Program::getFragmentOutputIndexes() const
{
   ASSERT(!mLinkingState);
   return mFragmentOutputIndexes;
}

const std::vector<GLsizei> &Program::getTransformFeedbackStrides() const
{
   ASSERT(!mLinkingState);
   return mState.mExecutable->getTransformFeedbackStrides();
}

GLint Program::getFragDataLocation(const std::string &name) const
{
   ASSERT(!mLinkingState);
   GLint primaryLocation = GetVariableLocation(mState.mExecutable->getOutputVariables(),
                                               mState.mExecutable->getOutputLocations(), name);
   if (primaryLocation != -1)
   {
       return primaryLocation;
   }
   return GetVariableLocation(mState.mExecutable->getOutputVariables(),
                              mState.mExecutable->getSecondaryOutputLocations(), name);
}

GLint Program::getFragDataIndex(const std::string &name) const
{
   ASSERT(!mLinkingState);
   if (GetVariableLocation(mState.mExecutable->getOutputVariables(),
                           mState.mExecutable->getOutputLocations(), name) != -1)
   {
       return 0;
   }
   if (GetVariableLocation(mState.mExecutable->getOutputVariables(),
                           mState.mExecutable->getSecondaryOutputLocations(), name) != -1)
   {
       return 1;
   }
   return -1;
}

void Program::getActiveUniform(GLuint index,
                              GLsizei bufsize,
                              GLsizei *length,
                              GLint *size,
                              GLenum *type,
                              GLchar *name) const
{
   ASSERT(!mLinkingState);
   if (mLinked)
   {
       // index must be smaller than getActiveUniformCount()
       ASSERT(index < mState.mExecutable->getUniforms().size());
       const LinkedUniform &uniform = mState.mExecutable->getUniforms()[index];

       if (bufsize > 0)
       {
           std::string string = uniform.name;
           CopyStringToBuffer(name, string, bufsize, length);
       }

       *size = clampCast<GLint>(uniform.getBasicTypeElementCount());
       *type = uniform.type;
   }
   else
   {
       if (bufsize > 0)
       {
           name[0] = '\0';
       }

       if (length)
       {
           *length = 0;
       }

       *size = 0;
       *type = GL_NONE;
   }
}

GLint Program::getActiveUniformCount() const
{
   ASSERT(!mLinkingState);
   if (mLinked)
   {
       return static_cast<GLint>(mState.mExecutable->getUniforms().size());
   }
   else
   {
       return 0;
   }
}

size_t Program::getActiveBufferVariableCount() const
{
   ASSERT(!mLinkingState);
   return mLinked ? mState.mBufferVariables.size() : 0;
}

GLint Program::getActiveUniformMaxLength() const
{
   ASSERT(!mLinkingState);
   size_t maxLength = 0;

   if (mLinked)
   {
       for (const LinkedUniform &uniform : mState.mExecutable->getUniforms())
       {
           if (!uniform.name.empty())
           {
               size_t length = uniform.name.length() + 1u;
               if (uniform.isArray())
               {
                   length += 3;  // Counting in "[0]".
               }
               maxLength = std::max(length, maxLength);
           }
       }
   }

   return static_cast<GLint>(maxLength);
}

bool Program::isValidUniformLocation(UniformLocation location) const
{
   ASSERT(!mLinkingState);
   ASSERT(angle::IsValueInRangeForNumericType<GLint>(mState.mUniformLocations.size()));
   return (location.value >= 0 &&
           static_cast<size_t>(location.value) < mState.mUniformLocations.size() &&
           mState.mUniformLocations[static_cast<size_t>(location.value)].used());
}

const LinkedUniform &Program::getUniformByLocation(UniformLocation location) const
{
   ASSERT(!mLinkingState);
   ASSERT(location.value >= 0 &&
          static_cast<size_t>(location.value) < mState.mUniformLocations.size());
   return mState.mExecutable->getUniforms()[mState.getUniformIndexFromLocation(location)];
}

const VariableLocation &Program::getUniformLocation(UniformLocation location) const
{
   ASSERT(!mLinkingState);
   ASSERT(location.value >= 0 &&
          static_cast<size_t>(location.value) < mState.mUniformLocations.size());
   return mState.mUniformLocations[location.value];
}

const BufferVariable &Program::getBufferVariableByIndex(GLuint index) const
{
   ASSERT(!mLinkingState);
   ASSERT(index < static_cast<size_t>(mState.mBufferVariables.size()));
   return mState.mBufferVariables[index];
}

UniformLocation Program::getUniformLocation(const std::string &name) const
{
   ASSERT(!mLinkingState);
   return {GetVariableLocation(mState.mExecutable->getUniforms(), mState.mUniformLocations, name)};
}

GLuint Program::getUniformIndex(const std::string &name) const
{
   ASSERT(!mLinkingState);
   return mState.getUniformIndexFromName(name);
}

bool Program::shouldIgnoreUniform(UniformLocation location) const
{
   if (location.value == -1)
   {
       return true;
   }

   if (mState.mUniformLocations[static_cast<size_t>(location.value)].ignored)
   {
       return true;
   }

   return false;
}

template <typename UniformT,
         GLint UniformSize,
         void (rx::ProgramImpl::*SetUniformFunc)(GLint, GLsizei, const UniformT *)>
void Program::setUniformGeneric(UniformLocation location, GLsizei count, const UniformT *v)
{
   ASSERT(!mLinkingState);
   if (shouldIgnoreUniform(location))
   {
       return;
   }

   const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
   GLsizei clampedCount                 = clampUniformCount(locationInfo, count, UniformSize, v);
   (mProgram->*SetUniformFunc)(location.value, clampedCount, v);
   onStateChange(angle::SubjectMessage::ProgramUniformUpdated);
}

void Program::setUniform1fv(UniformLocation location, GLsizei count, const GLfloat *v)
{
   setUniformGeneric<GLfloat, 1, &rx::ProgramImpl::setUniform1fv>(location, count, v);
}

void Program::setUniform2fv(UniformLocation location, GLsizei count, const GLfloat *v)
{
   setUniformGeneric<GLfloat, 2, &rx::ProgramImpl::setUniform2fv>(location, count, v);
}

void Program::setUniform3fv(UniformLocation location, GLsizei count, const GLfloat *v)
{
   setUniformGeneric<GLfloat, 3, &rx::ProgramImpl::setUniform3fv>(location, count, v);
}

void Program::setUniform4fv(UniformLocation location, GLsizei count, const GLfloat *v)
{
   setUniformGeneric<GLfloat, 4, &rx::ProgramImpl::setUniform4fv>(location, count, v);
}

void Program::setUniform1iv(Context *context,
                           UniformLocation location,
                           GLsizei count,
                           const GLint *v)
{
   ASSERT(!mLinkingState);
   if (shouldIgnoreUniform(location))
   {
       return;
   }

   const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
   GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);

   mProgram->setUniform1iv(location.value, clampedCount, v);

   if (mState.isSamplerUniformIndex(locationInfo.index))
   {
       updateSamplerUniform(context, locationInfo, clampedCount, v);
   }
   else
   {
       onStateChange(angle::SubjectMessage::ProgramUniformUpdated);
   }
}

void Program::setUniform2iv(UniformLocation location, GLsizei count, const GLint *v)
{
   setUniformGeneric<GLint, 2, &rx::ProgramImpl::setUniform2iv>(location, count, v);
}

void Program::setUniform3iv(UniformLocation location, GLsizei count, const GLint *v)
{
   setUniformGeneric<GLint, 3, &rx::ProgramImpl::setUniform3iv>(location, count, v);
}

void Program::setUniform4iv(UniformLocation location, GLsizei count, const GLint *v)
{
   setUniformGeneric<GLint, 4, &rx::ProgramImpl::setUniform4iv>(location, count, v);
}

void Program::setUniform1uiv(UniformLocation location, GLsizei count, const GLuint *v)
{
   setUniformGeneric<GLuint, 1, &rx::ProgramImpl::setUniform1uiv>(location, count, v);
}

void Program::setUniform2uiv(UniformLocation location, GLsizei count, const GLuint *v)
{
   setUniformGeneric<GLuint, 2, &rx::ProgramImpl::setUniform2uiv>(location, count, v);
}

void Program::setUniform3uiv(UniformLocation location, GLsizei count, const GLuint *v)
{
   setUniformGeneric<GLuint, 3, &rx::ProgramImpl::setUniform3uiv>(location, count, v);
}

void Program::setUniform4uiv(UniformLocation location, GLsizei count, const GLuint *v)
{
   setUniformGeneric<GLuint, 4, &rx::ProgramImpl::setUniform4uiv>(location, count, v);
}

template <
   typename UniformT,
   GLint MatrixC,
   GLint MatrixR,
   void (rx::ProgramImpl::*SetUniformMatrixFunc)(GLint, GLsizei, GLboolean, const UniformT *)>
void Program::setUniformMatrixGeneric(UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const UniformT *v)
{
   ASSERT(!mLinkingState);
   if (shouldIgnoreUniform(location))
   {
       return;
   }

   GLsizei clampedCount = clampMatrixUniformCount<MatrixC, MatrixR>(location, count, transpose, v);
   (mProgram->*SetUniformMatrixFunc)(location.value, clampedCount, transpose, v);
   onStateChange(angle::SubjectMessage::ProgramUniformUpdated);
}

void Program::setUniformMatrix2fv(UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *v)
{
   setUniformMatrixGeneric<GLfloat, 2, 2, &rx::ProgramImpl::setUniformMatrix2fv>(location, count,
                                                                                 transpose, v);
}

void Program::setUniformMatrix3fv(UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *v)
{
   setUniformMatrixGeneric<GLfloat, 3, 3, &rx::ProgramImpl::setUniformMatrix3fv>(location, count,
                                                                                 transpose, v);
}

void Program::setUniformMatrix4fv(UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *v)
{
   setUniformMatrixGeneric<GLfloat, 4, 4, &rx::ProgramImpl::setUniformMatrix4fv>(location, count,
                                                                                 transpose, v);
}

void Program::setUniformMatrix2x3fv(UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *v)
{
   setUniformMatrixGeneric<GLfloat, 2, 3, &rx::ProgramImpl::setUniformMatrix2x3fv>(location, count,
                                                                                   transpose, v);
}

void Program::setUniformMatrix2x4fv(UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *v)
{
   setUniformMatrixGeneric<GLfloat, 2, 4, &rx::ProgramImpl::setUniformMatrix2x4fv>(location, count,
                                                                                   transpose, v);
}

void Program::setUniformMatrix3x2fv(UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *v)
{
   setUniformMatrixGeneric<GLfloat, 3, 2, &rx::ProgramImpl::setUniformMatrix3x2fv>(location, count,
                                                                                   transpose, v);
}

void Program::setUniformMatrix3x4fv(UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *v)
{
   setUniformMatrixGeneric<GLfloat, 3, 4, &rx::ProgramImpl::setUniformMatrix3x4fv>(location, count,
                                                                                   transpose, v);
}

void Program::setUniformMatrix4x2fv(UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *v)
{
   setUniformMatrixGeneric<GLfloat, 4, 2, &rx::ProgramImpl::setUniformMatrix4x2fv>(location, count,
                                                                                   transpose, v);
}

void Program::setUniformMatrix4x3fv(UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *v)
{
   setUniformMatrixGeneric<GLfloat, 4, 3, &rx::ProgramImpl::setUniformMatrix4x3fv>(location, count,
                                                                                   transpose, v);
}

GLuint Program::getSamplerUniformBinding(const VariableLocation &uniformLocation) const
{
   ASSERT(!mLinkingState);
   GLuint samplerIndex = mState.getSamplerIndexFromUniformIndex(uniformLocation.index);
   const std::vector<GLuint> &boundTextureUnits =
       mState.mExecutable->mSamplerBindings[samplerIndex].boundTextureUnits;
   return (uniformLocation.arrayIndex < boundTextureUnits.size())
              ? boundTextureUnits[uniformLocation.arrayIndex]
              : 0;
}

GLuint Program::getImageUniformBinding(const VariableLocation &uniformLocation) const
{
   ASSERT(!mLinkingState);
   GLuint imageIndex = mState.getImageIndexFromUniformIndex(uniformLocation.index);

   const std::vector<ImageBinding> &imageBindings = getExecutable().getImageBindings();
   const std::vector<GLuint> &boundImageUnits     = imageBindings[imageIndex].boundImageUnits;
   return boundImageUnits[uniformLocation.arrayIndex];
}

void Program::getUniformfv(const Context *context, UniformLocation location, GLfloat *v) const
{
   ASSERT(!mLinkingState);
   const VariableLocation &uniformLocation = mState.getUniformLocations()[location.value];
   const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];

   if (uniform.isSampler())
   {
       *v = static_cast<GLfloat>(getSamplerUniformBinding(uniformLocation));
       return;
   }
   else if (uniform.isImage())
   {
       *v = static_cast<GLfloat>(getImageUniformBinding(uniformLocation));
       return;
   }

   const GLenum nativeType = gl::VariableComponentType(uniform.type);
   if (nativeType == GL_FLOAT)
   {
       mProgram->getUniformfv(context, location.value, v);
   }
   else
   {
       getUniformInternal(context, v, location, nativeType, VariableComponentCount(uniform.type));
   }
}

void Program::getUniformiv(const Context *context, UniformLocation location, GLint *v) const
{
   ASSERT(!mLinkingState);
   const VariableLocation &uniformLocation = mState.getUniformLocations()[location.value];
   const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];

   if (uniform.isSampler())
   {
       *v = static_cast<GLint>(getSamplerUniformBinding(uniformLocation));
       return;
   }
   else if (uniform.isImage())
   {
       *v = static_cast<GLint>(getImageUniformBinding(uniformLocation));
       return;
   }

   const GLenum nativeType = gl::VariableComponentType(uniform.type);
   if (nativeType == GL_INT || nativeType == GL_BOOL)
   {
       mProgram->getUniformiv(context, location.value, v);
   }
   else
   {
       getUniformInternal(context, v, location, nativeType, VariableComponentCount(uniform.type));
   }
}

void Program::getUniformuiv(const Context *context, UniformLocation location, GLuint *v) const
{
   ASSERT(!mLinkingState);
   const VariableLocation &uniformLocation = mState.getUniformLocations()[location.value];
   const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];

   if (uniform.isSampler())
   {
       *v = getSamplerUniformBinding(uniformLocation);
       return;
   }
   else if (uniform.isImage())
   {
       *v = getImageUniformBinding(uniformLocation);
       return;
   }

   const GLenum nativeType = VariableComponentType(uniform.type);
   if (nativeType == GL_UNSIGNED_INT)
   {
       mProgram->getUniformuiv(context, location.value, v);
   }
   else
   {
       getUniformInternal(context, v, location, nativeType, VariableComponentCount(uniform.type));
   }
}

void Program::flagForDeletion()
{
   ASSERT(!mLinkingState);
   mDeleteStatus = true;
}

bool Program::isFlaggedForDeletion() const
{
   ASSERT(!mLinkingState);
   return mDeleteStatus;
}

void Program::validate(const Caps &caps)
{
   ASSERT(!mLinkingState);
   mState.mExecutable->resetInfoLog();
   InfoLog &infoLog = mState.mExecutable->getInfoLog();

   if (mLinked)
   {
       mValidated = ConvertToBool(mProgram->validate(caps, &infoLog));
   }
   else
   {
       infoLog << "Program has not been successfully linked.";
   }
}

bool Program::isValidated() const
{
   ASSERT(!mLinkingState);
   return mValidated;
}

void Program::getActiveUniformBlockName(const Context *context,
                                       const UniformBlockIndex blockIndex,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLchar *blockName) const
{
   ASSERT(!mLinkingState);
   GetInterfaceBlockName(blockIndex, mState.mExecutable->getUniformBlocks(), bufSize, length,
                         blockName);
}

void Program::getActiveShaderStorageBlockName(const GLuint blockIndex,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLchar *blockName) const
{
   ASSERT(!mLinkingState);
   GetInterfaceBlockName({blockIndex}, mState.mExecutable->getShaderStorageBlocks(), bufSize,
                         length, blockName);
}

template <typename T>
GLint Program::getActiveInterfaceBlockMaxNameLength(const std::vector<T> &resources) const
{
   int maxLength = 0;

   if (mLinked)
   {
       for (const T &resource : resources)
       {
           if (!resource.name.empty())
           {
               int length = static_cast<int>(resource.nameWithArrayIndex().length());
               maxLength  = std::max(length + 1, maxLength);
           }
       }
   }

   return maxLength;
}

GLint Program::getActiveUniformBlockMaxNameLength() const
{
   ASSERT(!mLinkingState);
   return getActiveInterfaceBlockMaxNameLength(mState.mExecutable->getUniformBlocks());
}

GLint Program::getActiveShaderStorageBlockMaxNameLength() const
{
   ASSERT(!mLinkingState);
   return getActiveInterfaceBlockMaxNameLength(mState.mExecutable->getShaderStorageBlocks());
}

GLuint Program::getUniformBlockIndex(const std::string &name) const
{
   ASSERT(!mLinkingState);
   return GetInterfaceBlockIndex(mState.mExecutable->getUniformBlocks(), name);
}

GLuint Program::getShaderStorageBlockIndex(const std::string &name) const
{
   ASSERT(!mLinkingState);
   return GetInterfaceBlockIndex(mState.mExecutable->getShaderStorageBlocks(), name);
}

const InterfaceBlock &Program::getUniformBlockByIndex(GLuint index) const
{
   ASSERT(!mLinkingState);
   ASSERT(index < static_cast<GLuint>(mState.mExecutable->getActiveUniformBlockCount()));
   return mState.mExecutable->getUniformBlocks()[index];
}

const InterfaceBlock &Program::getShaderStorageBlockByIndex(GLuint index) const
{
   ASSERT(!mLinkingState);
   ASSERT(index < static_cast<GLuint>(mState.mExecutable->getActiveShaderStorageBlockCount()));
   return mState.mExecutable->getShaderStorageBlocks()[index];
}

void Program::bindUniformBlock(UniformBlockIndex uniformBlockIndex, GLuint uniformBlockBinding)
{
   ASSERT(!mLinkingState);
   mState.mExecutable->mUniformBlocks[uniformBlockIndex.value].binding = uniformBlockBinding;
   mState.mExecutable->mActiveUniformBlockBindings.set(uniformBlockIndex.value,
                                                       uniformBlockBinding != 0);
   mDirtyBits.set(DIRTY_BIT_UNIFORM_BLOCK_BINDING_0 + uniformBlockIndex.value);
}

GLuint Program::getUniformBlockBinding(GLuint uniformBlockIndex) const
{
   ASSERT(!mLinkingState);
   return mState.getUniformBlockBinding(uniformBlockIndex);
}

GLuint Program::getShaderStorageBlockBinding(GLuint shaderStorageBlockIndex) const
{
   ASSERT(!mLinkingState);
   return mState.getShaderStorageBlockBinding(shaderStorageBlockIndex);
}

void Program::setTransformFeedbackVaryings(GLsizei count,
                                          const GLchar *const *varyings,
                                          GLenum bufferMode)
{
   ASSERT(!mLinkingState);
   mState.mTransformFeedbackVaryingNames.resize(count);
   for (GLsizei i = 0; i < count; i++)
   {
       mState.mTransformFeedbackVaryingNames[i] = varyings[i];
   }

   mState.mExecutable->mTransformFeedbackBufferMode = bufferMode;
}

void Program::getTransformFeedbackVarying(GLuint index,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLsizei *size,
                                         GLenum *type,
                                         GLchar *name) const
{
   ASSERT(!mLinkingState);
   if (mLinked)
   {
       ASSERT(index < mState.mExecutable->mLinkedTransformFeedbackVaryings.size());
       const auto &var     = mState.mExecutable->mLinkedTransformFeedbackVaryings[index];
       std::string varName = var.nameWithArrayIndex();
       GLsizei lastNameIdx = std::min(bufSize - 1, static_cast<GLsizei>(varName.length()));
       if (length)
       {
           *length = lastNameIdx;
       }
       if (size)
       {
           *size = var.size();
       }
       if (type)
       {
           *type = var.type;
       }
       if (name)
       {
           memcpy(name, varName.c_str(), lastNameIdx);
           name[lastNameIdx] = '\0';
       }
   }
}

GLsizei Program::getTransformFeedbackVaryingCount() const
{
   ASSERT(!mLinkingState);
   if (mLinked)
   {
       return static_cast<GLsizei>(mState.mExecutable->mLinkedTransformFeedbackVaryings.size());
   }
   else
   {
       return 0;
   }
}

GLsizei Program::getTransformFeedbackVaryingMaxLength() const
{
   ASSERT(!mLinkingState);
   if (mLinked)
   {
       GLsizei maxSize = 0;
       for (const auto &var : mState.mExecutable->mLinkedTransformFeedbackVaryings)
       {
           maxSize =
               std::max(maxSize, static_cast<GLsizei>(var.nameWithArrayIndex().length() + 1));
       }

       return maxSize;
   }
   else
   {
       return 0;
   }
}

GLenum Program::getTransformFeedbackBufferMode() const
{
   ASSERT(!mLinkingState);
   return mState.mExecutable->getTransformFeedbackBufferMode();
}

bool Program::linkValidateShaders(const Context *context, InfoLog &infoLog)
{
   const ShaderMap<Shader *> &shaders = mState.mAttachedShaders;

   bool isComputeShaderAttached  = shaders[ShaderType::Compute] != nullptr;
   bool isGraphicsShaderAttached = shaders[ShaderType::Vertex] ||
                                   shaders[ShaderType::TessControl] ||
                                   shaders[ShaderType::TessEvaluation] ||
                                   shaders[ShaderType::Geometry] || shaders[ShaderType::Fragment];
   // Check whether we both have a compute and non-compute shaders attached.
   // If there are of both types attached, then linking should fail.
   // OpenGL ES 3.10, 7.3 Program Objects, under LinkProgram
   if (isComputeShaderAttached && isGraphicsShaderAttached)
   {
       infoLog << "Both compute and graphics shaders are attached to the same program.";
       return false;
   }

   Optional<int> version;
   for (ShaderType shaderType : kAllGraphicsShaderTypes)
   {
       Shader *shader = shaders[shaderType];
       ASSERT(!shader || shader->getType() == shaderType);
       if (!shader)
       {
           continue;
       }

       if (!shader->isCompiled(context))
       {
           infoLog << ShaderTypeToString(shaderType) << " shader is not compiled.";
           return false;
       }

       if (!version.valid())
       {
           version = shader->getShaderVersion(context);
       }
       else if (version != shader->getShaderVersion(context))
       {
           infoLog << ShaderTypeToString(shaderType)
                   << " shader version does not match other shader versions.";
           return false;
       }
   }

   if (isComputeShaderAttached)
   {
       ASSERT(shaders[ShaderType::Compute]->getType() == ShaderType::Compute);

       mState.mComputeShaderLocalSize = shaders[ShaderType::Compute]->getWorkGroupSize(context);

       // GLSL ES 3.10, 4.4.1.1 Compute Shader Inputs
       // If the work group size is not specified, a link time error should occur.
       if (!mState.mComputeShaderLocalSize.isDeclared())
       {
           infoLog << "Work group size is not specified.";
           return false;
       }
   }
   else
   {
       if (!isGraphicsShaderAttached)
       {
           infoLog << "No compiled shaders.";
           return false;
       }

       bool hasVertex   = shaders[ShaderType::Vertex] != nullptr;
       bool hasFragment = shaders[ShaderType::Fragment] != nullptr;
       if (!isSeparable() && (!hasVertex || !hasFragment))
       {
           infoLog
               << "The program must contain objects to form both a vertex and fragment shader.";
           return false;
       }

       bool hasTessControl    = shaders[ShaderType::TessControl] != nullptr;
       bool hasTessEvaluation = shaders[ShaderType::TessEvaluation] != nullptr;
       if (!isSeparable() && (hasTessControl != hasTessEvaluation))
       {
           infoLog << "Tessellation control and evaluation shaders must be specified together.";
           return false;
       }

       Shader *geometryShader = shaders[ShaderType::Geometry];
       if (shaders[ShaderType::Geometry])
       {
           // [GL_EXT_geometry_shader] Chapter 7
           // Linking can fail for a variety of reasons as specified in the OpenGL ES Shading
           // Language Specification, as well as any of the following reasons:
           // * One or more of the shader objects attached to <program> are not compiled
           //   successfully.
           // * The shaders do not use the same shader language version.
           // * <program> contains objects to form a geometry shader, and
           //   - <program> is not separable and contains no objects to form a vertex shader; or
           //   - the input primitive type, output primitive type, or maximum output vertex count
           //     is not specified in the compiled geometry shader object.
           ASSERT(geometryShader->getType() == ShaderType::Geometry);

           Optional<PrimitiveMode> inputPrimitive =
               geometryShader->getGeometryShaderInputPrimitiveType(context);
           if (!inputPrimitive.valid())
           {
               infoLog << "Input primitive type is not specified in the geometry shader.";
               return false;
           }

           Optional<PrimitiveMode> outputPrimitive =
               geometryShader->getGeometryShaderOutputPrimitiveType(context);
           if (!outputPrimitive.valid())
           {
               infoLog << "Output primitive type is not specified in the geometry shader.";
               return false;
           }

           Optional<GLint> maxVertices = geometryShader->getGeometryShaderMaxVertices(context);
           if (!maxVertices.valid())
           {
               infoLog << "'max_vertices' is not specified in the geometry shader.";
               return false;
           }

           mState.mExecutable->mGeometryShaderInputPrimitiveType  = inputPrimitive.value();
           mState.mExecutable->mGeometryShaderOutputPrimitiveType = outputPrimitive.value();
           mState.mExecutable->mGeometryShaderMaxVertices         = maxVertices.value();
           mState.mExecutable->mGeometryShaderInvocations =
               geometryShader->getGeometryShaderInvocations(context);
       }

       Shader *tessControlShader = shaders[ShaderType::TessControl];
       if (tessControlShader)
       {
           int tcsShaderVertices = tessControlShader->getTessControlShaderVertices(context);
           if (tcsShaderVertices == 0)
           {
               // In tessellation control shader, output vertices should be specified at least
               // once.
               // > GLSL ES Version 3.20.6 spec:
               // > 4.4.2. Output Layout Qualifiers
               // > Tessellation Control Outputs
               // > ...
               // > There must be at least one layout qualifier specifying an output patch vertex
               // > count in any program containing a tessellation control shader.
               infoLog << "In Tessellation Control Shader, at least one layout qualifier "
                          "specifying an output patch vertex count must exist.";
               return false;
           }

           mState.mExecutable->mTessControlShaderVertices = tcsShaderVertices;
       }

       Shader *tessEvaluationShader = shaders[ShaderType::TessEvaluation];
       if (tessEvaluationShader)
       {
           GLenum tesPrimitiveMode = tessEvaluationShader->getTessGenMode(context);
           if (tesPrimitiveMode == 0)
           {
               // In tessellation evaluation shader, a primitive mode should be specified at least
               // once.
               // > GLSL ES Version 3.20.6 spec:
               // > 4.4.1. Input Layout Qualifiers
               // > Tessellation Evaluation Inputs
               // > ...
               // > The tessellation evaluation shader object in a program must declare a primitive
               // > mode in its input layout. Declaring vertex spacing, ordering, or point mode
               // > identifiers is optional.
               infoLog << "The Tessellation Evaluation Shader object in a program must declare a "
                          "primitive mode in its input layout.";
               return false;
           }

           mState.mExecutable->mTessGenMode    = tesPrimitiveMode;
           mState.mExecutable->mTessGenSpacing = tessEvaluationShader->getTessGenSpacing(context);
           mState.mExecutable->mTessGenVertexOrder =
               tessEvaluationShader->getTessGenVertexOrder(context);
           mState.mExecutable->mTessGenPointMode =
               tessEvaluationShader->getTessGenPointMode(context);
       }
   }

   return true;
}

GLuint Program::getTransformFeedbackVaryingResourceIndex(const GLchar *name) const
{
   ASSERT(!mLinkingState);
   for (GLuint tfIndex = 0; tfIndex < mState.mExecutable->mLinkedTransformFeedbackVaryings.size();
        ++tfIndex)
   {
       const auto &tf = mState.mExecutable->mLinkedTransformFeedbackVaryings[tfIndex];
       if (tf.nameWithArrayIndex() == name)
       {
           return tfIndex;
       }
   }
   return GL_INVALID_INDEX;
}

const TransformFeedbackVarying &Program::getTransformFeedbackVaryingResource(GLuint index) const
{
   ASSERT(!mLinkingState);
   ASSERT(index < mState.mExecutable->mLinkedTransformFeedbackVaryings.size());
   return mState.mExecutable->mLinkedTransformFeedbackVaryings[index];
}

bool Program::hasDrawIDUniform() const
{
   ASSERT(!mLinkingState);
   return mState.mDrawIDLocation >= 0;
}

void Program::setDrawIDUniform(GLint drawid)
{
   ASSERT(!mLinkingState);
   ASSERT(mState.mDrawIDLocation >= 0);
   mProgram->setUniform1iv(mState.mDrawIDLocation, 1, &drawid);
}

bool Program::hasBaseVertexUniform() const
{
   ASSERT(!mLinkingState);
   return mState.mBaseVertexLocation >= 0;
}

void Program::setBaseVertexUniform(GLint baseVertex)
{
   ASSERT(!mLinkingState);
   ASSERT(mState.mBaseVertexLocation >= 0);
   if (baseVertex == mState.mCachedBaseVertex)
   {
       return;
   }
   mState.mCachedBaseVertex = baseVertex;
   mProgram->setUniform1iv(mState.mBaseVertexLocation, 1, &baseVertex);
}

bool Program::hasBaseInstanceUniform() const
{
   ASSERT(!mLinkingState);
   return mState.mBaseInstanceLocation >= 0;
}

void Program::setBaseInstanceUniform(GLuint baseInstance)
{
   ASSERT(!mLinkingState);
   ASSERT(mState.mBaseInstanceLocation >= 0);
   if (baseInstance == mState.mCachedBaseInstance)
   {
       return;
   }
   mState.mCachedBaseInstance = baseInstance;
   GLint baseInstanceInt      = baseInstance;
   mProgram->setUniform1iv(mState.mBaseInstanceLocation, 1, &baseInstanceInt);
}

bool Program::linkVaryings(const Context *context, InfoLog &infoLog) const
{
   ShaderType previousShaderType = ShaderType::InvalidEnum;
   for (ShaderType shaderType : kAllGraphicsShaderTypes)
   {
       Shader *currentShader = mState.mAttachedShaders[shaderType];
       if (!currentShader)
       {
           continue;
       }

       if (previousShaderType != ShaderType::InvalidEnum)
       {
           Shader *previousShader = mState.mAttachedShaders[previousShaderType];
           const std::vector<sh::ShaderVariable> &outputVaryings =
               previousShader->getOutputVaryings(context);

           if (!LinkValidateShaderInterfaceMatching(
                   outputVaryings, currentShader->getInputVaryings(context), previousShaderType,
                   currentShader->getType(), previousShader->getShaderVersion(context),
                   currentShader->getShaderVersion(context), isSeparable(), infoLog))
           {
               return false;
           }
       }
       previousShaderType = currentShader->getType();
   }

   // TODO: http://anglebug.com/3571 and http://anglebug.com/3572
   // Need to move logic of validating builtin varyings inside the for-loop above.
   // This is because the built-in symbols `gl_ClipDistance` and `gl_CullDistance`
   // can be redeclared in Geometry or Tessellation shaders as well.
   Shader *vertexShader   = mState.mAttachedShaders[ShaderType::Vertex];
   Shader *fragmentShader = mState.mAttachedShaders[ShaderType::Fragment];
   if (vertexShader && fragmentShader &&
       !LinkValidateBuiltInVaryings(vertexShader->getOutputVaryings(context),
                                    fragmentShader->getInputVaryings(context),
                                    vertexShader->getType(), fragmentShader->getType(),
                                    vertexShader->getShaderVersion(context),
                                    fragmentShader->getShaderVersion(context), infoLog))
   {
       return false;
   }

   return true;
}

bool Program::linkUniforms(const Context *context,
                          std::vector<UnusedUniform> *unusedUniformsOutOrNull,
                          GLuint *combinedImageUniformsOut,
                          InfoLog &infoLog)
{
   // Initialize executable shader map.
   ShaderMap<std::vector<sh::ShaderVariable>> shaderUniforms;
   for (Shader *shader : mState.mAttachedShaders)
   {
       if (shader)
       {
           shaderUniforms[shader->getType()] = shader->getUniforms(context);
       }
   }

   if (!mState.mExecutable->linkUniforms(context, shaderUniforms, infoLog,
                                         mState.mUniformLocationBindings, combinedImageUniformsOut,
                                         unusedUniformsOutOrNull, &mState.mUniformLocations))
   {
       return false;
   }

   if (context->getClientVersion() >= Version(3, 1))
   {
       GLint locationSize = static_cast<GLint>(mState.getUniformLocations().size());

       if (locationSize > context->getCaps().maxUniformLocations)
       {
           infoLog << "Exceeded maximum uniform location size";
           return false;
       }
   }

   return true;
}

// Assigns locations to all attributes (except built-ins) from the bindings and program locations.
bool Program::linkAttributes(const Context *context, InfoLog &infoLog)
{
   const Caps &caps               = context->getCaps();
   const Limitations &limitations = context->getLimitations();
   bool webglCompatibility        = context->isWebGL();
   int shaderVersion              = -1;
   unsigned int usedLocations     = 0;

   Shader *vertexShader = mState.getAttachedShader(gl::ShaderType::Vertex);

   if (!vertexShader)
   {
       // No vertex shader, so no attributes, so nothing to do
       return true;
   }

   shaderVersion = vertexShader->getShaderVersion(context);
   if (shaderVersion >= 300)
   {
       // In GLSL ES 3.00.6, aliasing checks should be done with all declared attributes -
       // see GLSL ES 3.00.6 section 12.46. Inactive attributes will be pruned after
       // aliasing checks.
       mState.mExecutable->mProgramInputs = vertexShader->getAllAttributes(context);
   }
   else
   {
       // In GLSL ES 1.00.17 we only do aliasing checks for active attributes.
       mState.mExecutable->mProgramInputs = vertexShader->getActiveAttributes(context);
   }

   GLuint maxAttribs = static_cast<GLuint>(caps.maxVertexAttributes);
   std::vector<sh::ShaderVariable *> usedAttribMap(maxAttribs, nullptr);

   // Assign locations to attributes that have a binding location and check for attribute aliasing.
   for (sh::ShaderVariable &attribute : mState.mExecutable->mProgramInputs)
   {
       // GLSL ES 3.10 January 2016 section 4.3.4: Vertex shader inputs can't be arrays or
       // structures, so we don't need to worry about adjusting their names or generating entries
       // for each member/element (unlike uniforms for example).
       ASSERT(!attribute.isArray() && !attribute.isStruct());

       int bindingLocation = mAttributeBindings.getBinding(attribute);
       if (attribute.location == -1 && bindingLocation != -1)
       {
           attribute.location = bindingLocation;
       }

       if (attribute.location != -1)
       {
           // Location is set by glBindAttribLocation or by location layout qualifier
           const int regs = VariableRegisterCount(attribute.type);

           if (static_cast<GLuint>(regs + attribute.location) > maxAttribs)
           {
               infoLog << "Attribute (" << attribute.name << ") at location " << attribute.location
                       << " is too big to fit";

               return false;
           }

           for (int reg = 0; reg < regs; reg++)
           {
               const int regLocation               = attribute.location + reg;
               sh::ShaderVariable *linkedAttribute = usedAttribMap[regLocation];

               // In GLSL ES 3.00.6 and in WebGL, attribute aliasing produces a link error.
               // In non-WebGL GLSL ES 1.00.17, attribute aliasing is allowed with some
               // restrictions - see GLSL ES 1.00.17 section 2.10.4, but ANGLE currently has a bug.
               // In D3D 9 and 11, aliasing is not supported, so check a limitation.
               if (linkedAttribute)
               {
                   if (shaderVersion >= 300 || webglCompatibility ||
                       limitations.noVertexAttributeAliasing)
                   {
                       infoLog << "Attribute '" << attribute.name << "' aliases attribute '"
                               << linkedAttribute->name << "' at location " << regLocation;
                       return false;
                   }
               }
               else
               {
                   usedAttribMap[regLocation] = &attribute;
               }

               usedLocations |= 1 << regLocation;
           }
       }
   }

   // Assign locations to attributes that don't have a binding location.
   for (sh::ShaderVariable &attribute : mState.mExecutable->mProgramInputs)
   {
       // Not set by glBindAttribLocation or by location layout qualifier
       if (attribute.location == -1)
       {
           int regs           = VariableRegisterCount(attribute.type);
           int availableIndex = AllocateFirstFreeBits(&usedLocations, regs, maxAttribs);

           if (availableIndex == -1 || static_cast<GLuint>(availableIndex + regs) > maxAttribs)
           {
               infoLog << "Too many attributes (" << attribute.name << ")";
               return false;
           }

           attribute.location = availableIndex;
       }
   }

   ASSERT(mState.mExecutable->mAttributesTypeMask.none());
   ASSERT(mState.mExecutable->mAttributesMask.none());

   // Prune inactive attributes. This step is only needed on shaderVersion >= 300 since on earlier
   // shader versions we're only processing active attributes to begin with.
   if (shaderVersion >= 300)
   {
       for (auto attributeIter = mState.mExecutable->getProgramInputs().begin();
            attributeIter != mState.mExecutable->getProgramInputs().end();)
       {
           if (attributeIter->active)
           {
               ++attributeIter;
           }
           else
           {
               attributeIter = mState.mExecutable->mProgramInputs.erase(attributeIter);
           }
       }
   }

   for (const sh::ShaderVariable &attribute : mState.mExecutable->getProgramInputs())
   {
       ASSERT(attribute.active);
       ASSERT(attribute.location != -1);
       unsigned int regs = static_cast<unsigned int>(VariableRegisterCount(attribute.type));

       unsigned int location = static_cast<unsigned int>(attribute.location);
       for (unsigned int r = 0; r < regs; r++)
       {
           // Built-in active program inputs don't have a bound attribute.
           if (!attribute.isBuiltIn())
           {
               mState.mExecutable->mActiveAttribLocationsMask.set(location);
               mState.mExecutable->mMaxActiveAttribLocation =
                   std::max(mState.mExecutable->mMaxActiveAttribLocation, location + 1);

               ComponentType componentType =
                   GLenumToComponentType(VariableComponentType(attribute.type));

               SetComponentTypeMask(componentType, location,
                                    &mState.mExecutable->mAttributesTypeMask);
               mState.mExecutable->mAttributesMask.set(location);

               location++;
           }
       }
   }

   return true;
}

void Program::setUniformValuesFromBindingQualifiers()
{
   for (unsigned int samplerIndex : mState.mExecutable->getSamplerUniformRange())
   {
       const auto &samplerUniform = mState.mExecutable->getUniforms()[samplerIndex];
       if (samplerUniform.binding != -1)
       {
           UniformLocation location = getUniformLocation(samplerUniform.name);
           ASSERT(location.value != -1);
           std::vector<GLint> boundTextureUnits;
           for (unsigned int elementIndex = 0;
                elementIndex < samplerUniform.getBasicTypeElementCount(); ++elementIndex)
           {
               boundTextureUnits.push_back(samplerUniform.binding + elementIndex);
           }

           // Here we pass nullptr to avoid a large chain of calls that need a non-const Context.
           // We know it's safe not to notify the Context because this is only called after link.
           setUniform1iv(nullptr, location, static_cast<GLsizei>(boundTextureUnits.size()),
                         boundTextureUnits.data());
       }
   }
}

void Program::initInterfaceBlockBindings()
{
   // Set initial bindings from shader.
   for (unsigned int blockIndex = 0; blockIndex < mState.mExecutable->getActiveUniformBlockCount();
        blockIndex++)
   {
       InterfaceBlock &uniformBlock = mState.mExecutable->mUniformBlocks[blockIndex];
       bindUniformBlock({blockIndex}, uniformBlock.binding);
   }
}

void Program::updateSamplerUniform(Context *context,
                                  const VariableLocation &locationInfo,
                                  GLsizei clampedCount,
                                  const GLint *v)
{
   ASSERT(mState.isSamplerUniformIndex(locationInfo.index));
   GLuint samplerIndex            = mState.getSamplerIndexFromUniformIndex(locationInfo.index);
   SamplerBinding &samplerBinding = mState.mExecutable->mSamplerBindings[samplerIndex];
   std::vector<GLuint> &boundTextureUnits = samplerBinding.boundTextureUnits;

   if (locationInfo.arrayIndex >= boundTextureUnits.size())
   {
       return;
   }
   GLsizei safeUniformCount = std::min(
       clampedCount, static_cast<GLsizei>(boundTextureUnits.size() - locationInfo.arrayIndex));

   // Update the sampler uniforms.
   for (GLsizei arrayIndex = 0; arrayIndex < safeUniformCount; ++arrayIndex)
   {
       GLint oldTextureUnit = boundTextureUnits[arrayIndex + locationInfo.arrayIndex];
       GLint newTextureUnit = v[arrayIndex];

       if (oldTextureUnit == newTextureUnit)
       {
           continue;
       }

       // Update sampler's bound textureUnit
       boundTextureUnits[arrayIndex + locationInfo.arrayIndex] = newTextureUnit;

       // Update the reference counts.
       uint32_t &oldRefCount = mState.mExecutable->mActiveSamplerRefCounts[oldTextureUnit];
       uint32_t &newRefCount = mState.mExecutable->mActiveSamplerRefCounts[newTextureUnit];
       ASSERT(oldRefCount > 0);
       ASSERT(newRefCount < std::numeric_limits<uint32_t>::max());
       oldRefCount--;
       newRefCount++;

       // Check for binding type change.
       TextureType newSamplerType     = mState.mExecutable->mActiveSamplerTypes[newTextureUnit];
       TextureType oldSamplerType     = mState.mExecutable->mActiveSamplerTypes[oldTextureUnit];
       SamplerFormat newSamplerFormat = mState.mExecutable->mActiveSamplerFormats[newTextureUnit];
       SamplerFormat oldSamplerFormat = mState.mExecutable->mActiveSamplerFormats[oldTextureUnit];
       bool newSamplerYUV             = mState.mExecutable->mActiveSamplerYUV.test(newTextureUnit);

       if (newRefCount == 1)
       {
           mState.mExecutable->setActive(newTextureUnit, samplerBinding,
                                         mState.mExecutable->getUniforms()[locationInfo.index]);
       }
       else
       {
           if (newSamplerType != samplerBinding.textureType ||
               newSamplerYUV != IsSamplerYUVType(samplerBinding.samplerType))
           {
               mState.mExecutable->hasSamplerTypeConflict(newTextureUnit);
           }

           if (newSamplerFormat != samplerBinding.format)
           {
               mState.mExecutable->hasSamplerFormatConflict(newTextureUnit);
           }
       }

       // Unset previously active sampler.
       if (oldRefCount == 0)
       {
           mState.mExecutable->setInactive(oldTextureUnit);
       }
       else
       {
           if (oldSamplerType == TextureType::InvalidEnum ||
               oldSamplerFormat == SamplerFormat::InvalidEnum)
           {
               // Previous conflict. Check if this new change fixed the conflict.
               mState.setSamplerUniformTextureTypeAndFormat(oldTextureUnit);
           }
       }

       // Update the observing PPO's executable, if any.
       // Do this before any of the Context work, since that uses the current ProgramExecutable,
       // which will be the PPO's if this Program is bound to it, rather than this Program's.
       if (isSeparable())
       {
           onStateChange(angle::SubjectMessage::ProgramTextureOrImageBindingChanged);
       }

       // Notify context.
       if (context)
       {
           context->onSamplerUniformChange(newTextureUnit);
           context->onSamplerUniformChange(oldTextureUnit);
       }
   }

   // Invalidate the validation cache.
   getExecutable().resetCachedValidateSamplersResult();
   // Inform any PPOs this Program may be bound to.
   onStateChange(angle::SubjectMessage::SamplerUniformsUpdated);
}

void ProgramState::setSamplerUniformTextureTypeAndFormat(size_t textureUnitIndex)
{
   mExecutable->setSamplerUniformTextureTypeAndFormat(textureUnitIndex,
                                                      mExecutable->mSamplerBindings);
}

template <typename T>
GLsizei Program::clampUniformCount(const VariableLocation &locationInfo,
                                  GLsizei count,
                                  int vectorSize,
                                  const T *v)
{
   if (count == 1)
       return 1;

   const LinkedUniform &linkedUniform = mState.mExecutable->getUniforms()[locationInfo.index];

   // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array
   // element index used, as reported by GetActiveUniform, will be ignored by the GL."
   unsigned int remainingElements =
       linkedUniform.getBasicTypeElementCount() - locationInfo.arrayIndex;
   GLsizei maxElementCount =
       static_cast<GLsizei>(remainingElements * linkedUniform.getElementComponents());

   if (count * vectorSize > maxElementCount)
   {
       return maxElementCount / vectorSize;
   }

   return count;
}

template <size_t cols, size_t rows, typename T>
GLsizei Program::clampMatrixUniformCount(UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const T *v)
{
   const VariableLocation &locationInfo = mState.mUniformLocations[location.value];

   if (!transpose)
   {
       return clampUniformCount(locationInfo, count, cols * rows, v);
   }

   const LinkedUniform &linkedUniform = mState.mExecutable->getUniforms()[locationInfo.index];

   // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array
   // element index used, as reported by GetActiveUniform, will be ignored by the GL."
   unsigned int remainingElements =
       linkedUniform.getBasicTypeElementCount() - locationInfo.arrayIndex;
   return std::min(count, static_cast<GLsizei>(remainingElements));
}

// Driver differences mean that doing the uniform value cast ourselves gives consistent results.
// EG: on NVIDIA drivers, it was observed that getUniformi for MAX_INT+1 returned MIN_INT.
template <typename DestT>
void Program::getUniformInternal(const Context *context,
                                DestT *dataOut,
                                UniformLocation location,
                                GLenum nativeType,
                                int components) const
{
   switch (nativeType)
   {
       case GL_BOOL:
       {
           GLint tempValue[16] = {0};
           mProgram->getUniformiv(context, location.value, tempValue);
           UniformStateQueryCastLoop<GLboolean>(
               dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
           break;
       }
       case GL_INT:
       {
           GLint tempValue[16] = {0};
           mProgram->getUniformiv(context, location.value, tempValue);
           UniformStateQueryCastLoop<GLint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
                                            components);
           break;
       }
       case GL_UNSIGNED_INT:
       {
           GLuint tempValue[16] = {0};
           mProgram->getUniformuiv(context, location.value, tempValue);
           UniformStateQueryCastLoop<GLuint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
                                             components);
           break;
       }
       case GL_FLOAT:
       {
           GLfloat tempValue[16] = {0};
           mProgram->getUniformfv(context, location.value, tempValue);
           UniformStateQueryCastLoop<GLfloat>(
               dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
           break;
       }
       default:
           UNREACHABLE();
           break;
   }
}

angle::Result Program::syncState(const Context *context)
{
   if (mDirtyBits.any())
   {
       ASSERT(!mLinkingState);
       ANGLE_TRY(mProgram->syncState(context, mDirtyBits));
       mDirtyBits.reset();
   }

   return angle::Result::Continue;
}

angle::Result Program::serialize(const Context *context, angle::MemoryBuffer *binaryOut) const
{
   BinaryOutputStream stream;

   stream.writeBytes(reinterpret_cast<const unsigned char *>(angle::GetANGLECommitHash()),
                     angle::GetANGLECommitHashSize());

   // nullptr context is supported when computing binary length.
   if (context)
   {
       stream.writeInt(context->getClientVersion().major);
       stream.writeInt(context->getClientVersion().minor);
   }
   else
   {
       stream.writeInt(2);
       stream.writeInt(0);
   }

   // Must be before mExecutable->save(), since it uses the value.
   stream.writeBool(mState.mSeparable);

   mState.mExecutable->save(mState.mSeparable, &stream);

   const auto &computeLocalSize = mState.getComputeShaderLocalSize();

   stream.writeInt(computeLocalSize[0]);
   stream.writeInt(computeLocalSize[1]);
   stream.writeInt(computeLocalSize[2]);

   stream.writeInt(mState.mNumViews);
   stream.writeInt(mState.mSpecConstUsageBits.bits());

   stream.writeInt(mState.getUniformLocations().size());
   for (const auto &variable : mState.getUniformLocations())
   {
       stream.writeInt(variable.arrayIndex);
       stream.writeIntOrNegOne(variable.index);
       stream.writeBool(variable.ignored);
   }

   stream.writeInt(mState.getBufferVariables().size());
   for (const BufferVariable &bufferVariable : mState.getBufferVariables())
   {
       WriteBufferVariable(&stream, bufferVariable);
   }

   // Warn the app layer if saving a binary with unsupported transform feedback.
   if (!mState.getLinkedTransformFeedbackVaryings().empty() &&
       context->getFrontendFeatures().disableProgramCachingForTransformFeedback.enabled)
   {
       ANGLE_PERF_WARNING(context->getState().getDebug(), GL_DEBUG_SEVERITY_LOW,
                          "Saving program binary with transform feedback, which is not supported "
                          "on this driver.");
   }

   if (context->getShareGroup()->getFrameCaptureShared()->enabled())
   {
       // Serialize the source for each stage for re-use during capture
       for (ShaderType shaderType : mState.mExecutable->getLinkedShaderStages())
       {
           gl::Shader *shader = getAttachedShader(shaderType);
           if (shader)
           {
               stream.writeString(shader->getSourceString());
           }
           else
           {
               // If we don't have an attached shader, which would occur if this program was
               // created via glProgramBinary, pull from our cached copy
               const angle::ProgramSources &cachedLinkedSources =
                   context->getShareGroup()->getFrameCaptureShared()->getProgramSources(id());
               const std::string &cachedSourceString = cachedLinkedSources[shaderType];
               ASSERT(!cachedSourceString.empty());
               stream.writeString(cachedSourceString.c_str());
           }
       }
   }

   mProgram->save(context, &stream);

   ASSERT(binaryOut);
   if (!binaryOut->resize(stream.length()))
   {
       std::stringstream sstream;
       sstream << "Failed to allocate enough memory to serialize a program. (" << stream.length()
               << " bytes )";
       ANGLE_PERF_WARNING(context->getState().getDebug(), GL_DEBUG_SEVERITY_LOW,
                          sstream.str().c_str());
       return angle::Result::Incomplete;
   }
   memcpy(binaryOut->data(), stream.data(), stream.length());
   return angle::Result::Continue;
}

angle::Result Program::deserialize(const Context *context,
                                  BinaryInputStream &stream,
                                  InfoLog &infoLog)
{
   std::vector<uint8_t> commitString(angle::GetANGLECommitHashSize(), 0);
   stream.readBytes(commitString.data(), commitString.size());
   if (memcmp(commitString.data(), angle::GetANGLECommitHash(), commitString.size()) != 0)
   {
       infoLog << "Invalid program binary version.";
       return angle::Result::Stop;
   }

   int majorVersion = stream.readInt<int>();
   int minorVersion = stream.readInt<int>();
   if (majorVersion != context->getClientMajorVersion() ||
       minorVersion != context->getClientMinorVersion())
   {
       infoLog << "Cannot load program binaries across different ES context versions.";
       return angle::Result::Stop;
   }

   // Must be before mExecutable->load(), since it uses the value.
   mState.mSeparable = stream.readBool();

   mState.mExecutable->load(mState.mSeparable, &stream);

   mState.mComputeShaderLocalSize[0] = stream.readInt<int>();
   mState.mComputeShaderLocalSize[1] = stream.readInt<int>();
   mState.mComputeShaderLocalSize[2] = stream.readInt<int>();

   mState.mNumViews = stream.readInt<int>();

   static_assert(sizeof(mState.mSpecConstUsageBits.bits()) == sizeof(uint32_t));
   mState.mSpecConstUsageBits = rx::SpecConstUsageBits(stream.readInt<uint32_t>());

   const size_t uniformIndexCount = stream.readInt<size_t>();
   ASSERT(mState.mUniformLocations.empty());
   for (size_t uniformIndexIndex = 0; uniformIndexIndex < uniformIndexCount; ++uniformIndexIndex)
   {
       VariableLocation variable;
       stream.readInt(&variable.arrayIndex);
       stream.readInt(&variable.index);
       stream.readBool(&variable.ignored);

       mState.mUniformLocations.push_back(variable);
   }

   size_t bufferVariableCount = stream.readInt<size_t>();
   ASSERT(mState.mBufferVariables.empty());
   for (size_t bufferVarIndex = 0; bufferVarIndex < bufferVariableCount; ++bufferVarIndex)
   {
       BufferVariable bufferVariable;
       LoadBufferVariable(&stream, &bufferVariable);
       mState.mBufferVariables.push_back(bufferVariable);
   }

   static_assert(static_cast<unsigned long>(ShaderType::EnumCount) <= sizeof(unsigned long) * 8,
                 "Too many shader types");

   // Reject programs that use transform feedback varyings if the hardware cannot support them.
   if (mState.mExecutable->getLinkedTransformFeedbackVaryings().size() > 0 &&
       context->getFrontendFeatures().disableProgramCachingForTransformFeedback.enabled)
   {
       infoLog << "Current driver does not support transform feedback in binary programs.";
       return angle::Result::Stop;
   }

   if (!mState.mAttachedShaders[ShaderType::Compute])
   {
       mState.mExecutable->updateTransformFeedbackStrides();
   }

   postResolveLink(context);
   mState.mExecutable->updateCanDrawWith();

   if (context->getShareGroup()->getFrameCaptureShared()->enabled())
   {
       // Extract the source for each stage from the program binary
       angle::ProgramSources sources;

       for (ShaderType shaderType : mState.mExecutable->getLinkedShaderStages())
       {
           std::string shaderSource = stream.readString();
           ASSERT(shaderSource.length() > 0);
           sources[shaderType] = std::move(shaderSource);
       }

       // Store it for use during mid-execution capture
       context->getShareGroup()->getFrameCaptureShared()->setProgramSources(id(),
                                                                            std::move(sources));
   }

   return angle::Result::Continue;
}

void Program::postResolveLink(const gl::Context *context)
{
   mState.updateActiveSamplers();
   mState.mExecutable->mActiveImageShaderBits.fill({});
   mState.mExecutable->updateActiveImages(getExecutable());

   setUniformValuesFromBindingQualifiers();

   if (context->getExtensions().multiDrawANGLE)
   {
       mState.mDrawIDLocation = getUniformLocation("gl_DrawID").value;
   }

   if (context->getExtensions().baseVertexBaseInstanceShaderBuiltinANGLE)
   {
       mState.mBaseVertexLocation   = getUniformLocation("gl_BaseVertex").value;
       mState.mBaseInstanceLocation = getUniformLocation("gl_BaseInstance").value;
   }
}
}  // namespace gl