kc3-lang/angle/src/libANGLE/Program.cpp

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2018-07-12 23:56:30
  Hash : 21061026
  Message : Vulkan: Use angle::Result error handling. Introduces a vk::Context class to contain an error handler and Renderer pointer. This abtracts the common code path for ContextVk + DisplayVk. Removes vk::Error in favor of the POD angle::Result class. There are a few remaining usages of gl::Error that will have to be cleaned up when we can change the front-end APIs. Bug: angleproject:2713 Change-Id: I5e68f223d595c6c561b59d6a85759e5738ed43c6 Reviewed-on: https://chromium-review.googlesource.com/1128924 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: Frank Henigman <fjhenigman@chromium.org>

• src/libANGLE/Program.cpp

• //
  // Copyright (c) 2002-2014 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 "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/MemoryProgramCache.h"
  #include "libANGLE/ProgramLinkedResources.h"
  #include "libANGLE/ResourceManager.h"
  #include "libANGLE/Uniform.h"
  #include "libANGLE/VaryingPacking.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/Platform.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;
  }
  
  template <typename VarT>
  GLint GetVariableLocation(const std::vector<VarT> &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 VarT &variable = list[variableLocation.index];
  
          if (angle::BeginsWith(variable.name, name))
          {
              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 *length)
  {
      ASSERT(bufSize > 0);
      strncpy(buffer, string.c_str(), bufSize);
      buffer[bufSize - 1] = '\0';
  
      if (length)
      {
          *length = static_cast<GLsizei>(strlen(buffer));
      }
  }
  
  bool IncludeSameArrayElement(const std::set<std::string> &nameSet, const std::string &name)
  {
      std::vector<unsigned int> subscripts;
      std::string baseName = ParseResourceName(name, &subscripts);
      for (auto nameInSet : nameSet)
      {
          std::vector<unsigned int> arrayIndices;
          std::string arrayName = ParseResourceName(nameInSet, &arrayIndices);
          if (baseName == arrayName &&
              (subscripts.empty() || arrayIndices.empty() || subscripts == arrayIndices))
          {
              return true;
          }
      }
      return false;
  }
  
  std::string GetInterfaceBlockLimitName(ShaderType shaderType, sh::BlockType blockType)
  {
      std::ostringstream stream;
      stream << "GL_MAX_" << GetShaderTypeString(shaderType) << "_";
  
      switch (blockType)
      {
          case sh::BlockType::BLOCK_UNIFORM:
              stream << "UNIFORM_BUFFERS";
              break;
          case sh::BlockType::BLOCK_BUFFER:
              stream << "SHADER_STORAGE_BLOCKS";
              break;
          default:
              UNREACHABLE();
              return "";
      }
  
      if (shaderType == ShaderType::Geometry)
      {
          stream << "_EXT";
      }
  
      return stream.str();
  }
  
  const char *GetInterfaceBlockTypeString(sh::BlockType blockType)
  {
      switch (blockType)
      {
          case sh::BlockType::BLOCK_UNIFORM:
              return "uniform block";
          case sh::BlockType::BLOCK_BUFFER:
              return "shader storage block";
          default:
              UNREACHABLE();
              return "";
      }
  }
  
  void LogInterfaceBlocksExceedLimit(InfoLog &infoLog,
                                     ShaderType shaderType,
                                     sh::BlockType blockType,
                                     GLuint limit)
  {
      infoLog << GetShaderTypeString(shaderType) << " shader "
              << GetInterfaceBlockTypeString(blockType) << " count exceeds "
              << GetInterfaceBlockLimitName(shaderType, blockType) << " (" << limit << ")";
  }
  
  bool ValidateInterfaceBlocksCount(GLuint maxInterfaceBlocks,
                                    const std::vector<sh::InterfaceBlock> &interfaceBlocks,
                                    ShaderType shaderType,
                                    sh::BlockType blockType,
                                    GLuint *combinedInterfaceBlocksCount,
                                    InfoLog &infoLog)
  {
      GLuint blockCount = 0;
      for (const sh::InterfaceBlock &block : interfaceBlocks)
      {
          if (IsActiveInterfaceBlock(block))
          {
              blockCount += std::max(block.arraySize, 1u);
              if (blockCount > maxInterfaceBlocks)
              {
                  LogInterfaceBlocksExceedLimit(infoLog, shaderType, blockType, maxInterfaceBlocks);
                  return false;
              }
          }
      }
  
      // [OpenGL ES 3.1] Chapter 7.6.2 Page 105:
      // If a uniform block is used by multiple shader stages, each such use counts separately
      // against this combined limit.
      // [OpenGL ES 3.1] Chapter 7.8 Page 111:
      // If a shader storage block in a program is referenced by multiple shaders, each such
      // reference counts separately against this combined limit.
      if (combinedInterfaceBlocksCount)
      {
          *combinedInterfaceBlocksCount += blockCount;
      }
  
      return true;
  }
  
  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 GLuint index,
                             const std::vector<InterfaceBlock> &list,
                             GLsizei bufSize,
                             GLsizei *length,
                             GLchar *name)
  {
      ASSERT(index < list.size());
  
      const auto &block = list[index];
  
      if (bufSize > 0)
      {
          std::string blockName = block.name;
  
          if (block.isArray)
          {
              blockName += ArrayString(block.arrayElement);
          }
          CopyStringToBuffer(name, blockName, bufSize, length);
      }
  }
  
  void InitUniformBlockLinker(const gl::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 gl::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));
          }
      }
  }
  
  // Find the matching varying or field by name.
  const sh::ShaderVariable *FindVaryingOrField(const ProgramMergedVaryings &varyings,
                                               const std::string &name)
  {
      const sh::ShaderVariable *var = nullptr;
      for (const auto &ref : varyings)
      {
          const sh::Varying *varying = ref.second.get();
          if (varying->name == name)
          {
              var = varying;
              break;
          }
          var = FindShaderVarField(*varying, name);
          if (var != nullptr)
          {
              break;
          }
      }
      return var;
  }
  
  void AddParentPrefix(const std::string &parentName, std::string *mismatchedFieldName)
  {
      ASSERT(mismatchedFieldName);
      if (mismatchedFieldName->empty())
      {
          *mismatchedFieldName = parentName;
      }
      else
      {
          std::ostringstream stream;
          stream << parentName << "." << *mismatchedFieldName;
          *mismatchedFieldName = stream.str();
      }
  }
  
  const char *GetLinkMismatchErrorString(LinkMismatchError linkError)
  {
      switch (linkError)
      {
          case LinkMismatchError::TYPE_MISMATCH:
              return "Type";
          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 qualilfier";
  
          case LinkMismatchError::LAYOUT_QUALIFIER_MISMATCH:
              return "Layout qualifier";
          case LinkMismatchError::MATRIX_PACKING_MISMATCH:
              return "Matrix Packing";
          default:
              UNREACHABLE();
              return "";
      }
  }
  
  LinkMismatchError LinkValidateInterfaceBlockFields(const sh::InterfaceBlockField &blockField1,
                                                     const sh::InterfaceBlockField &blockField2,
                                                     bool webglCompatibility,
                                                     std::string *mismatchedBlockFieldName)
  {
      if (blockField1.name != blockField2.name)
      {
          return LinkMismatchError::FIELD_NAME_MISMATCH;
      }
  
      // If webgl, validate precision of UBO fields, otherwise don't.  See Khronos bug 10287.
      LinkMismatchError linkError = Program::LinkValidateVariablesBase(
          blockField1, blockField2, webglCompatibility, true, mismatchedBlockFieldName);
      if (linkError != LinkMismatchError::NO_MISMATCH)
      {
          AddParentPrefix(blockField1.name, mismatchedBlockFieldName);
          return linkError;
      }
  
      if (blockField1.isRowMajorLayout != blockField2.isRowMajorLayout)
      {
          AddParentPrefix(blockField1.name, mismatchedBlockFieldName);
          return LinkMismatchError::MATRIX_PACKING_MISMATCH;
      }
  
      return LinkMismatchError::NO_MISMATCH;
  }
  
  LinkMismatchError AreMatchingInterfaceBlocks(const sh::InterfaceBlock &interfaceBlock1,
                                               const sh::InterfaceBlock &interfaceBlock2,
                                               bool webglCompatibility,
                                               std::string *mismatchedBlockFieldName)
  {
      // validate blocks for the same member types
      if (interfaceBlock1.fields.size() != interfaceBlock2.fields.size())
      {
          return LinkMismatchError::FIELD_NUMBER_MISMATCH;
      }
      if (interfaceBlock1.arraySize != interfaceBlock2.arraySize)
      {
          return LinkMismatchError::ARRAY_SIZE_MISMATCH;
      }
      if (interfaceBlock1.layout != interfaceBlock2.layout ||
          interfaceBlock1.binding != interfaceBlock2.binding)
      {
          return LinkMismatchError::LAYOUT_QUALIFIER_MISMATCH;
      }
      const unsigned int numBlockMembers = static_cast<unsigned int>(interfaceBlock1.fields.size());
      for (unsigned int blockMemberIndex = 0; blockMemberIndex < numBlockMembers; blockMemberIndex++)
      {
          const sh::InterfaceBlockField &member1 = interfaceBlock1.fields[blockMemberIndex];
          const sh::InterfaceBlockField &member2 = interfaceBlock2.fields[blockMemberIndex];
  
          LinkMismatchError linkError = LinkValidateInterfaceBlockFields(
              member1, member2, webglCompatibility, mismatchedBlockFieldName);
          if (linkError != LinkMismatchError::NO_MISMATCH)
          {
              return linkError;
          }
      }
      return LinkMismatchError::NO_MISMATCH;
  }
  
  using ShaderInterfaceBlock = std::pair<ShaderType, const sh::InterfaceBlock *>;
  using InterfaceBlockMap    = std::map<std::string, ShaderInterfaceBlock>;
  
  void InitializeInterfaceBlockMap(const std::vector<sh::InterfaceBlock> &interfaceBlocks,
                                   ShaderType shaderType,
                                   InterfaceBlockMap *linkedInterfaceBlocks)
  {
      ASSERT(linkedInterfaceBlocks);
  
      for (const sh::InterfaceBlock &interfaceBlock : interfaceBlocks)
      {
          (*linkedInterfaceBlocks)[interfaceBlock.name] = std::make_pair(shaderType, &interfaceBlock);
      }
  }
  
  bool ValidateGraphicsInterfaceBlocksPerShader(
      const std::vector<sh::InterfaceBlock> &interfaceBlocksToLink,
      ShaderType shaderType,
      bool webglCompatibility,
      InterfaceBlockMap *linkedBlocks,
      InfoLog &infoLog)
  {
      ASSERT(linkedBlocks);
  
      for (const sh::InterfaceBlock &block : interfaceBlocksToLink)
      {
          const auto &entry = linkedBlocks->find(block.name);
          if (entry != linkedBlocks->end())
          {
              const sh::InterfaceBlock &linkedBlock = *(entry->second.second);
              std::string mismatchedStructFieldName;
              LinkMismatchError linkError = AreMatchingInterfaceBlocks(
                  block, linkedBlock, webglCompatibility, &mismatchedStructFieldName);
              if (linkError != LinkMismatchError::NO_MISMATCH)
              {
                  LogLinkMismatch(infoLog, block.name, GetInterfaceBlockTypeString(block.blockType),
                                  linkError, mismatchedStructFieldName, entry->second.first,
                                  shaderType);
                  return false;
              }
          }
          else
          {
              (*linkedBlocks)[block.name] = std::make_pair(shaderType, &block);
          }
      }
  
      return true;
  }
  
  bool ValidateInterfaceBlocksMatch(
      GLuint numShadersHasInterfaceBlocks,
      const ShaderMap<const std::vector<sh::InterfaceBlock> *> &shaderInterfaceBlocks,
      InfoLog &infoLog,
      bool webglCompatibility)
  {
      if (numShadersHasInterfaceBlocks < 2u)
      {
          return true;
      }
  
      ASSERT(!shaderInterfaceBlocks[ShaderType::Compute]);
  
      // Check that interface blocks defined in the graphics shaders are identical
  
      InterfaceBlockMap linkedInterfaceBlocks;
  
      bool interfaceBlockMapInitialized = false;
      for (ShaderType shaderType : kAllGraphicsShaderTypes)
      {
          if (!shaderInterfaceBlocks[shaderType])
          {
              continue;
          }
  
          if (!interfaceBlockMapInitialized)
          {
              InitializeInterfaceBlockMap(*shaderInterfaceBlocks[shaderType], shaderType,
                                          &linkedInterfaceBlocks);
              interfaceBlockMapInitialized = true;
          }
          else if (!ValidateGraphicsInterfaceBlocksPerShader(*shaderInterfaceBlocks[shaderType],
                                                             shaderType, webglCompatibility,
                                                             &linkedInterfaceBlocks, infoLog))
          {
              return false;
          }
      }
  
      return true;
  }
  
  }  // anonymous namespace
  
  const char *const g_fakepath = "C:\\fakepath";
  
  // InfoLog implementation.
  InfoLog::InfoLog()
  {
  }
  
  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 santized 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);
  
      *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;
  }
  
  // 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, size_t elementCount, bool unreferenced)
      : textureType(textureTypeIn), boundTextureUnits(elementCount, 0), unreferenced(unreferenced)
  {
  }
  
  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::getBinding(const std::string &name) const
  {
      auto iter = mBindings.find(name);
      return (iter != mBindings.end()) ? iter->second : -1;
  }
  
  ProgramBindings::const_iterator ProgramBindings::begin() const
  {
      return mBindings.begin();
  }
  
  ProgramBindings::const_iterator ProgramBindings::end() const
  {
      return mBindings.end();
  }
  
  // ImageBinding implementation.
  ImageBinding::ImageBinding(size_t count) : boundImageUnits(count, 0)
  {
  }
  ImageBinding::ImageBinding(GLuint imageUnit, size_t count)
  {
      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({}),
        mTransformFeedbackBufferMode(GL_INTERLEAVED_ATTRIBS),
        mMaxActiveAttribLocation(0),
        mSamplerUniformRange(0, 0),
        mImageUniformRange(0, 0),
        mAtomicCounterUniformRange(0, 0),
        mBinaryRetrieveableHint(false),
        mNumViews(-1),
        // [GL_EXT_geometry_shader] Table 20.22
        mGeometryShaderInputPrimitiveType(PrimitiveMode::Triangles),
        mGeometryShaderOutputPrimitiveType(PrimitiveMode::TriangleStrip),
        mGeometryShaderInvocations(1),
        mGeometryShaderMaxVertices(0)
  {
      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(mUniforms, name);
  }
  
  GLuint ProgramState::getBufferVariableIndexFromName(const std::string &name) const
  {
      return GetResourceIndexFromName(mBufferVariables, name);
  }
  
  GLuint ProgramState::getUniformIndexFromLocation(GLint location) const
  {
      ASSERT(location >= 0 && static_cast<size_t>(location) < mUniformLocations.size());
      return mUniformLocations[location].index;
  }
  
  Optional<GLuint> ProgramState::getSamplerIndex(GLint location) const
  {
      GLuint index = getUniformIndexFromLocation(location);
      if (!isSamplerUniformIndex(index))
      {
          return Optional<GLuint>::Invalid();
      }
  
      return getSamplerIndexFromUniformIndex(index);
  }
  
  bool ProgramState::isSamplerUniformIndex(GLuint index) const
  {
      return mSamplerUniformRange.contains(index);
  }
  
  GLuint ProgramState::getSamplerIndexFromUniformIndex(GLuint uniformIndex) const
  {
      ASSERT(isSamplerUniformIndex(uniformIndex));
      return uniformIndex - mSamplerUniformRange.low();
  }
  
  GLuint ProgramState::getAttributeLocation(const std::string &name) const
  {
      for (const sh::Attribute &attribute : mAttributes)
      {
          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;
  }
  
  Program::Program(rx::GLImplFactory *factory, ShaderProgramManager *manager, GLuint handle)
      : 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)
  {
      for (ShaderType shaderType : AllShaderTypes())
      {
          if (mState.mAttachedShaders[shaderType])
          {
              mState.mAttachedShaders[shaderType]->release(context);
              mState.mAttachedShaders[shaderType] = nullptr;
          }
      }
  
      // TODO(jmadill): Handle error in the Context. http://anglebug.com/2491
      ANGLE_SWALLOW_ERR(mProgram->destroy(context));
  
      ASSERT(!mState.hasAttachedShader());
      SafeDelete(mProgram);
  
      delete this;
  }
  
  void Program::setLabel(const std::string &label)
  {
      mState.mLabel = label;
  }
  
  const std::string &Program::getLabel() const
  {
      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)
  {
      ShaderType shaderType = shader->getType();
      ASSERT(shaderType != ShaderType::InvalidEnum);
  
      ASSERT(mState.mAttachedShaders[shaderType] == shader);
      shader->release(context);
      mState.mAttachedShaders[shaderType] = nullptr;
  }
  
  int Program::getAttachedShadersCount() const
  {
      int numAttachedShaders = 0;
      for (const Shader *shader : mState.mAttachedShaders)
      {
          if (shader)
          {
              ++numAttachedShaders;
          }
      }
  
      return numAttachedShaders;
  }
  
  const Shader *Program::getAttachedShader(ShaderType shaderType) const
  {
      return mState.getAttachedShader(shaderType);
  }
  
  void Program::bindAttributeLocation(GLuint index, const char *name)
  {
      mAttributeBindings.bindLocation(index, name);
  }
  
  void Program::bindUniformLocation(GLuint index, const char *name)
  {
      mUniformLocationBindings.bindLocation(index, name);
  }
  
  void Program::bindFragmentInputLocation(GLint index, const char *name)
  {
      mFragmentInputBindings.bindLocation(index, name);
  }
  
  BindingInfo Program::getFragmentInputBindingInfo(const Context *context, GLint index) const
  {
      BindingInfo ret;
      ret.type  = GL_NONE;
      ret.valid = false;
  
      Shader *fragmentShader = mState.getAttachedShader(ShaderType::Fragment);
      ASSERT(fragmentShader);
  
      // Find the actual fragment shader varying we're interested in
      const std::vector<sh::Varying> &inputs = fragmentShader->getInputVaryings(context);
  
      for (const auto &binding : mFragmentInputBindings)
      {
          if (binding.second != static_cast<GLuint>(index))
              continue;
  
          ret.valid = true;
  
          size_t nameLengthWithoutArrayIndex;
          unsigned int arrayIndex = ParseArrayIndex(binding.first, &nameLengthWithoutArrayIndex);
  
          for (const auto &in : inputs)
          {
              if (in.name.length() == nameLengthWithoutArrayIndex &&
                  angle::BeginsWith(in.name, binding.first, nameLengthWithoutArrayIndex))
              {
                  if (in.isArray())
                  {
                      // The client wants to bind either "name" or "name[0]".
                      // GL ES 3.1 spec refers to active array names with language such as:
                      // "if 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".
                      if (arrayIndex == GL_INVALID_INDEX)
                          arrayIndex = 0;
  
                      ret.name = in.mappedName + "[" + ToString(arrayIndex) + "]";
                  }
                  else
                  {
                      ret.name = in.mappedName;
                  }
                  ret.type = in.type;
                  return ret;
              }
          }
      }
  
      return ret;
  }
  
  void Program::pathFragmentInputGen(const Context *context,
                                     GLint index,
                                     GLenum genMode,
                                     GLint components,
                                     const GLfloat *coeffs)
  {
      // If the location is -1 then the command is silently ignored
      if (index == -1)
          return;
  
      const auto &binding = getFragmentInputBindingInfo(context, index);
  
      // If the input doesn't exist then then the command is silently ignored
      // This could happen through optimization for example, the shader translator
      // decides that a variable is not actually being used and optimizes it away.
      if (binding.name.empty())
          return;
  
      mProgram->setPathFragmentInputGen(binding.name, genMode, components, coeffs);
  }
  
  // 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.
  Error Program::link(const gl::Context *context)
  {
      const auto &data = context->getContextState();
  
      auto *platform   = ANGLEPlatformCurrent();
      double startTime = platform->currentTime(platform);
  
      unlink();
      mInfoLog.reset();
  
      // Validate we have properly attached shaders before checking the cache.
      if (!linkValidateShaders(context, mInfoLog))
      {
          return NoError();
      }
  
      ProgramHash programHash;
      MemoryProgramCache *cache = context->getMemoryProgramCache();
      if (cache)
      {
          ANGLE_TRY_RESULT(cache->getProgram(context, this, &mState, &programHash), mLinked);
          ANGLE_HISTOGRAM_BOOLEAN("GPU.ANGLE.ProgramCache.LoadBinarySuccess", mLinked);
      }
  
      if (mLinked)
      {
          double delta = platform->currentTime(platform) - startTime;
          int us       = static_cast<int>(delta * 1000000.0);
          ANGLE_HISTOGRAM_COUNTS("GPU.ANGLE.ProgramCache.ProgramCacheHitTimeUS", us);
          return NoError();
      }
  
      // Cache load failed, fall through to normal linking.
      unlink();
  
      // Re-link shaders after the unlink call.
      ASSERT(linkValidateShaders(context, mInfoLog));
  
      if (mState.mAttachedShaders[ShaderType::Compute])
      {
          ProgramLinkedResources resources = {
              {0, PackMode::ANGLE_RELAXED},
              {&mState.mUniformBlocks, &mState.mUniforms},
              {&mState.mShaderStorageBlocks, &mState.mBufferVariables},
              {&mState.mAtomicCounterBuffers},
              {}};
  
          GLuint combinedImageUniforms = 0u;
          if (!linkUniforms(context, mInfoLog, mUniformLocationBindings, &combinedImageUniforms,
                            &resources.unusedUniforms))
          {
              return NoError();
          }
  
          GLuint combinedShaderStorageBlocks = 0u;
          if (!linkInterfaceBlocks(context, mInfoLog, &combinedShaderStorageBlocks))
          {
              return NoError();
          }
  
          // [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 >
              context->getCaps().maxCombinedShaderOutputResources)
          {
              mInfoLog
                  << "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 NoError();
          }
  
          InitUniformBlockLinker(context, mState, &resources.uniformBlockLinker);
          InitShaderStorageBlockLinker(context, mState, &resources.shaderStorageBlockLinker);
  
          ANGLE_TRY_RESULT(mProgram->link(context, resources, mInfoLog), mLinked);
          if (!mLinked)
          {
              return NoError();
          }
      }
      else
      {
          // Map the varyings to the register file
          // In WebGL, we use a slightly different handling for packing variables.
          gl::PackMode packMode = PackMode::ANGLE_RELAXED;
          if (data.getLimitations().noFlexibleVaryingPacking)
          {
              // D3D9 pack mode is strictly more strict than WebGL, so takes priority.
              packMode = PackMode::ANGLE_NON_CONFORMANT_D3D9;
          }
          else if (data.getExtensions().webglCompatibility)
          {
              packMode = PackMode::WEBGL_STRICT;
          }
  
          ProgramLinkedResources resources = {
              {data.getCaps().maxVaryingVectors, packMode},
              {&mState.mUniformBlocks, &mState.mUniforms},
              {&mState.mShaderStorageBlocks, &mState.mBufferVariables},
              {&mState.mAtomicCounterBuffers},
              {}};
  
          if (!linkAttributes(context, mInfoLog))
          {
              return NoError();
          }
  
          if (!linkVaryings(context, mInfoLog))
          {
              return NoError();
          }
  
          GLuint combinedImageUniforms = 0u;
          if (!linkUniforms(context, mInfoLog, mUniformLocationBindings, &combinedImageUniforms,
                            &resources.unusedUniforms))
          {
              return NoError();
          }
  
          GLuint combinedShaderStorageBlocks = 0u;
          if (!linkInterfaceBlocks(context, mInfoLog, &combinedShaderStorageBlocks))
          {
              return NoError();
          }
  
          if (!linkValidateGlobalNames(context, mInfoLog))
          {
              return NoError();
          }
  
          if (!linkOutputVariables(context, combinedImageUniforms, combinedShaderStorageBlocks))
          {
              return NoError();
          }
  
          const auto &mergedVaryings = getMergedVaryings(context);
  
          ASSERT(mState.mAttachedShaders[ShaderType::Vertex]);
          mState.mNumViews = mState.mAttachedShaders[ShaderType::Vertex]->getNumViews(context);
  
          InitUniformBlockLinker(context, mState, &resources.uniformBlockLinker);
          InitShaderStorageBlockLinker(context, mState, &resources.shaderStorageBlockLinker);
  
          if (!linkValidateTransformFeedback(context, mInfoLog, mergedVaryings, context->getCaps()))
          {
              return NoError();
          }
  
          if (!resources.varyingPacking.collectAndPackUserVaryings(
                  mInfoLog, mergedVaryings, mState.getTransformFeedbackVaryingNames()))
          {
              return NoError();
          }
  
          ANGLE_TRY_RESULT(mProgram->link(context, resources, mInfoLog), mLinked);
          if (!mLinked)
          {
              return NoError();
          }
  
          gatherTransformFeedbackVaryings(mergedVaryings);
      }
  
      initInterfaceBlockBindings();
  
      setUniformValuesFromBindingQualifiers();
  
      // According to GLES 3.0/3.1 spec for LinkProgram and UseProgram,
      // Only successfully linked program can replace the executables.
      ASSERT(mLinked);
      updateLinkedShaderStages();
  
      // Mark implementation-specific unreferenced uniforms as ignored.
      mProgram->markUnusedUniformLocations(&mState.mUniformLocations, &mState.mSamplerBindings);
  
      // Save to the program cache.
      if (cache && (mState.mLinkedTransformFeedbackVaryings.empty() ||
                    !context->getWorkarounds().disableProgramCachingForTransformFeedback))
      {
          cache->putProgram(programHash, context, this);
      }
  
      double delta = platform->currentTime(platform) - startTime;
      int us       = static_cast<int>(delta * 1000000.0);
      ANGLE_HISTOGRAM_COUNTS("GPU.ANGLE.ProgramCache.ProgramCacheMissTimeUS", us);
  
      return NoError();
  }
  
  void Program::updateLinkedShaderStages()
  {
      mState.mLinkedShaderStages.reset();
  
      for (const Shader *shader : mState.mAttachedShaders)
      {
          if (shader)
          {
              mState.mLinkedShaderStages.set(shader->getType());
          }
      }
  }
  
  void ProgramState::updateTransformFeedbackStrides()
  {
      if (mTransformFeedbackBufferMode == GL_INTERLEAVED_ATTRIBS)
      {
          mTransformFeedbackStrides.resize(1);
          size_t totalSize = 0;
          for (auto &varying : mLinkedTransformFeedbackVaryings)
          {
              totalSize += varying.size() * VariableExternalSize(varying.type);
          }
          mTransformFeedbackStrides[0] = static_cast<GLsizei>(totalSize);
      }
      else
      {
          mTransformFeedbackStrides.resize(mLinkedTransformFeedbackVaryings.size());
          for (size_t i = 0; i < mLinkedTransformFeedbackVaryings.size(); i++)
          {
              auto &varying = mLinkedTransformFeedbackVaryings[i];
              mTransformFeedbackStrides[i] =
                  static_cast<GLsizei>(varying.size() * VariableExternalSize(varying.type));
          }
      }
  }
  
  // Returns the program object to an unlinked state, before re-linking, or at destruction
  void Program::unlink()
  {
      mState.mAttributes.clear();
      mState.mAttributesTypeMask.reset();
      mState.mAttributesMask.reset();
      mState.mActiveAttribLocationsMask.reset();
      mState.mMaxActiveAttribLocation = 0;
      mState.mLinkedTransformFeedbackVaryings.clear();
      mState.mUniforms.clear();
      mState.mUniformLocations.clear();
      mState.mUniformBlocks.clear();
      mState.mActiveUniformBlockBindings.reset();
      mState.mAtomicCounterBuffers.clear();
      mState.mOutputVariables.clear();
      mState.mOutputLocations.clear();
      mState.mOutputVariableTypes.clear();
      mState.mDrawBufferTypeMask.reset();
      mState.mActiveOutputVariables.reset();
      mState.mComputeShaderLocalSize.fill(1);
      mState.mSamplerBindings.clear();
      mState.mImageBindings.clear();
      mState.mNumViews                          = -1;
      mState.mGeometryShaderInputPrimitiveType  = PrimitiveMode::Triangles;
      mState.mGeometryShaderOutputPrimitiveType = PrimitiveMode::TriangleStrip;
      mState.mGeometryShaderInvocations         = 1;
      mState.mGeometryShaderMaxVertices         = 0;
  
      mValidated = false;
  
      mLinked = false;
      mInfoLog.reset();
  }
  
  bool Program::hasLinkedShaderStage(ShaderType shaderType) const
  {
      ASSERT(shaderType != ShaderType::InvalidEnum);
      return mState.mLinkedShaderStages[shaderType];
  }
  
  Error Program::loadBinary(const Context *context,
                            GLenum binaryFormat,
                            const void *binary,
                            GLsizei length)
  {
      unlink();
  
  #if ANGLE_PROGRAM_BINARY_LOAD != ANGLE_ENABLED
      return NoError();
  #else
      ASSERT(binaryFormat == GL_PROGRAM_BINARY_ANGLE);
      if (binaryFormat != GL_PROGRAM_BINARY_ANGLE)
      {
          mInfoLog << "Invalid program binary format.";
          return NoError();
      }
  
      const uint8_t *bytes = reinterpret_cast<const uint8_t *>(binary);
      ANGLE_TRY_RESULT(
          MemoryProgramCache::Deserialize(context, this, &mState, bytes, length, mInfoLog), mLinked);
  
      // Currently we require the full shader text to compute the program hash.
      // TODO(jmadill): Store the binary in the internal program cache.
  
      return NoError();
  #endif  // #if ANGLE_PROGRAM_BINARY_LOAD == ANGLE_ENABLED
  }
  
  Error Program::saveBinary(const Context *context,
                            GLenum *binaryFormat,
                            void *binary,
                            GLsizei bufSize,
                            GLsizei *length) const
  {
      if (binaryFormat)
      {
          *binaryFormat = GL_PROGRAM_BINARY_ANGLE;
      }
  
      angle::MemoryBuffer memoryBuf;
      MemoryProgramCache::Serialize(context, this, &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.
          return InternalError();
      }
  
      if (binary)
      {
          char *ptr = reinterpret_cast<char *>(binary);
  
          memcpy(ptr, streamState, streamLength);
          ptr += streamLength;
  
          ASSERT(ptr - streamLength == binary);
      }
  
      if (length)
      {
          *length = streamLength;
      }
  
      return NoError();
  }
  
  GLint Program::getBinaryLength(const Context *context) const
  {
      if (!mLinked)
      {
          return 0;
      }
  
      GLint length;
      Error error = saveBinary(context, nullptr, nullptr, std::numeric_limits<GLint>::max(), &length);
      if (error.isError())
      {
          return 0;
      }
  
      return length;
  }
  
  void Program::setBinaryRetrievableHint(bool retrievable)
  {
      // TODO(jmadill) : replace with dirty bits
      mProgram->setBinaryRetrievableHint(retrievable);
      mState.mBinaryRetrieveableHint = retrievable;
  }
  
  bool Program::getBinaryRetrievableHint() const
  {
      return mState.mBinaryRetrieveableHint;
  }
  
  void Program::setSeparable(bool separable)
  {
      // TODO(yunchao) : replace with dirty bits
      if (mState.mSeparable != separable)
      {
          mProgram->setSeparable(separable);
          mState.mSeparable = separable;
      }
  }
  
  bool Program::isSeparable() const
  {
      return mState.mSeparable;
  }
  
  void Program::release(const Context *context)
  {
      mRefCount--;
  
      if (mRefCount == 0 && mDeleteStatus)
      {
          mResourceManager->deleteProgram(context, mHandle);
      }
  }
  
  void Program::addRef()
  {
      mRefCount++;
  }
  
  unsigned int Program::getRefCount() const
  {
      return mRefCount;
  }
  
  int Program::getInfoLogLength() const
  {
      return static_cast<int>(mInfoLog.getLength());
  }
  
  void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const
  {
      return mInfoLog.getLog(bufSize, length, infoLog);
  }
  
  void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders) const
  {
      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
  {
      return mState.getAttributeLocation(name);
  }
  
  bool Program::isAttribLocationActive(size_t attribLocation) const
  {
      ASSERT(attribLocation < mState.mActiveAttribLocationsMask.size());
      return mState.mActiveAttribLocationsMask[attribLocation];
  }
  
  void Program::getActiveAttribute(GLuint index,
                                   GLsizei bufsize,
                                   GLsizei *length,
                                   GLint *size,
                                   GLenum *type,
                                   GLchar *name) const
  {
      if (!mLinked)
      {
          if (bufsize > 0)
          {
              name[0] = '\0';
          }
  
          if (length)
          {
              *length = 0;
          }
  
          *type = GL_NONE;
          *size = 1;
          return;
      }
  
      ASSERT(index < mState.mAttributes.size());
      const sh::Attribute &attrib = mState.mAttributes[index];
  
      if (bufsize > 0)
      {
          CopyStringToBuffer(name, attrib.name, bufsize, length);
      }
  
      // Always a single 'type' instance
      *size = 1;
      *type = attrib.type;
  }
  
  GLint Program::getActiveAttributeCount() const
  {
      if (!mLinked)
      {
          return 0;
      }
  
      return static_cast<GLint>(mState.mAttributes.size());
  }
  
  GLint Program::getActiveAttributeMaxLength() const
  {
      if (!mLinked)
      {
          return 0;
      }
  
      size_t maxLength = 0;
  
      for (const sh::Attribute &attrib : mState.mAttributes)
      {
          maxLength = std::max(attrib.name.length() + 1, maxLength);
      }
  
      return static_cast<GLint>(maxLength);
  }
  
  GLuint Program::getInputResourceIndex(const GLchar *name) const
  {
      return GetResourceIndexFromName(mState.mAttributes, std::string(name));
  }
  
  GLuint Program::getOutputResourceIndex(const GLchar *name) const
  {
      return GetResourceIndexFromName(mState.mOutputVariables, std::string(name));
  }
  
  size_t Program::getOutputResourceCount() const
  {
      return (mLinked ? mState.mOutputVariables.size() : 0);
  }
  
  template <typename T>
  void Program::getResourceName(GLuint index,
                                const std::vector<T> &resources,
                                GLsizei bufSize,
                                GLsizei *length,
                                GLchar *name) const
  {
      if (length)
      {
          *length = 0;
      }
  
      if (!mLinked)
      {
          if (bufSize > 0)
          {
              name[0] = '\0';
          }
          return;
      }
      ASSERT(index < resources.size());
      const auto &resource = resources[index];
  
      if (bufSize > 0)
      {
          CopyStringToBuffer(name, resource.name, bufSize, length);
      }
  }
  
  void Program::getInputResourceName(GLuint index,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *name) const
  {
      getResourceName(index, mState.mAttributes, bufSize, length, name);
  }
  
  void Program::getOutputResourceName(GLuint index,
                                      GLsizei bufSize,
                                      GLsizei *length,
                                      GLchar *name) const
  {
      getResourceName(index, mState.mOutputVariables, bufSize, length, name);
  }
  
  void Program::getUniformResourceName(GLuint index,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLchar *name) const
  {
      getResourceName(index, mState.mUniforms, bufSize, length, name);
  }
  
  void Program::getBufferVariableResourceName(GLuint index,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLchar *name) const
  {
      getResourceName(index, mState.mBufferVariables, bufSize, length, name);
  }
  
  const sh::Attribute &Program::getInputResource(GLuint index) const
  {
      ASSERT(index < mState.mAttributes.size());
      return mState.mAttributes[index];
  }
  
  const sh::OutputVariable &Program::getOutputResource(GLuint index) const
  {
      ASSERT(index < mState.mOutputVariables.size());
      return mState.mOutputVariables[index];
  }
  
  GLint Program::getFragDataLocation(const std::string &name) const
  {
      return GetVariableLocation(mState.mOutputVariables, mState.mOutputLocations, name);
  }
  
  void Program::getActiveUniform(GLuint index,
                                 GLsizei bufsize,
                                 GLsizei *length,
                                 GLint *size,
                                 GLenum *type,
                                 GLchar *name) const
  {
      if (mLinked)
      {
          // index must be smaller than getActiveUniformCount()
          ASSERT(index < mState.mUniforms.size());
          const LinkedUniform &uniform = mState.mUniforms[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
  {
      if (mLinked)
      {
          return static_cast<GLint>(mState.mUniforms.size());
      }
      else
      {
          return 0;
      }
  }
  
  size_t Program::getActiveBufferVariableCount() const
  {
      return mLinked ? mState.mBufferVariables.size() : 0;
  }
  
  GLint Program::getActiveUniformMaxLength() const
  {
      size_t maxLength = 0;
  
      if (mLinked)
      {
          for (const LinkedUniform &uniform : mState.mUniforms)
          {
              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(GLint location) const
  {
      ASSERT(angle::IsValueInRangeForNumericType<GLint>(mState.mUniformLocations.size()));
      return (location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size() &&
              mState.mUniformLocations[static_cast<size_t>(location)].used());
  }
  
  const LinkedUniform &Program::getUniformByLocation(GLint location) const
  {
      ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size());
      return mState.mUniforms[mState.getUniformIndexFromLocation(location)];
  }
  
  const VariableLocation &Program::getUniformLocation(GLint location) const
  {
      ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size());
      return mState.mUniformLocations[location];
  }
  
  const BufferVariable &Program::getBufferVariableByIndex(GLuint index) const
  {
      ASSERT(index < static_cast<size_t>(mState.mBufferVariables.size()));
      return mState.mBufferVariables[index];
  }
  
  GLint Program::getUniformLocation(const std::string &name) const
  {
      return GetVariableLocation(mState.mUniforms, mState.mUniformLocations, name);
  }
  
  GLuint Program::getUniformIndex(const std::string &name) const
  {
      return mState.getUniformIndexFromName(name);
  }
  
  void Program::setUniform1fv(GLint location, GLsizei count, const GLfloat *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
      mProgram->setUniform1fv(location, clampedCount, v);
  }
  
  void Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
      mProgram->setUniform2fv(location, clampedCount, v);
  }
  
  void Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
      mProgram->setUniform3fv(location, clampedCount, v);
  }
  
  void Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
      mProgram->setUniform4fv(location, clampedCount, v);
  }
  
  Program::SetUniformResult Program::setUniform1iv(GLint location, GLsizei count, const GLint *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
  
      mProgram->setUniform1iv(location, clampedCount, v);
  
      if (mState.isSamplerUniformIndex(locationInfo.index))
      {
          updateSamplerUniform(locationInfo, clampedCount, v);
          return SetUniformResult::SamplerChanged;
      }
  
      return SetUniformResult::NoSamplerChange;
  }
  
  void Program::setUniform2iv(GLint location, GLsizei count, const GLint *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
      mProgram->setUniform2iv(location, clampedCount, v);
  }
  
  void Program::setUniform3iv(GLint location, GLsizei count, const GLint *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
      mProgram->setUniform3iv(location, clampedCount, v);
  }
  
  void Program::setUniform4iv(GLint location, GLsizei count, const GLint *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
      mProgram->setUniform4iv(location, clampedCount, v);
  }
  
  void Program::setUniform1uiv(GLint location, GLsizei count, const GLuint *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
      mProgram->setUniform1uiv(location, clampedCount, v);
  }
  
  void Program::setUniform2uiv(GLint location, GLsizei count, const GLuint *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
      mProgram->setUniform2uiv(location, clampedCount, v);
  }
  
  void Program::setUniform3uiv(GLint location, GLsizei count, const GLuint *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
      mProgram->setUniform3uiv(location, clampedCount, v);
  }
  
  void Program::setUniform4uiv(GLint location, GLsizei count, const GLuint *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
      mProgram->setUniform4uiv(location, clampedCount, v);
  }
  
  void Program::setUniformMatrix2fv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *v)
  {
      GLsizei clampedCount = clampMatrixUniformCount<2, 2>(location, count, transpose, v);
      mProgram->setUniformMatrix2fv(location, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix3fv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *v)
  {
      GLsizei clampedCount = clampMatrixUniformCount<3, 3>(location, count, transpose, v);
      mProgram->setUniformMatrix3fv(location, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix4fv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *v)
  {
      GLsizei clampedCount = clampMatrixUniformCount<4, 4>(location, count, transpose, v);
      mProgram->setUniformMatrix4fv(location, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix2x3fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      GLsizei clampedCount = clampMatrixUniformCount<2, 3>(location, count, transpose, v);
      mProgram->setUniformMatrix2x3fv(location, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix2x4fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      GLsizei clampedCount = clampMatrixUniformCount<2, 4>(location, count, transpose, v);
      mProgram->setUniformMatrix2x4fv(location, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix3x2fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      GLsizei clampedCount = clampMatrixUniformCount<3, 2>(location, count, transpose, v);
      mProgram->setUniformMatrix3x2fv(location, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix3x4fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      GLsizei clampedCount = clampMatrixUniformCount<3, 4>(location, count, transpose, v);
      mProgram->setUniformMatrix3x4fv(location, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix4x2fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      GLsizei clampedCount = clampMatrixUniformCount<4, 2>(location, count, transpose, v);
      mProgram->setUniformMatrix4x2fv(location, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix4x3fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      GLsizei clampedCount = clampMatrixUniformCount<4, 3>(location, count, transpose, v);
      mProgram->setUniformMatrix4x3fv(location, clampedCount, transpose, v);
  }
  
  GLuint Program::getSamplerUniformBinding(const VariableLocation &uniformLocation) const
  {
      GLuint samplerIndex = mState.getSamplerIndexFromUniformIndex(uniformLocation.index);
      const std::vector<GLuint> &boundTextureUnits =
          mState.mSamplerBindings[samplerIndex].boundTextureUnits;
      return boundTextureUnits[uniformLocation.arrayIndex];
  }
  
  void Program::getUniformfv(const Context *context, GLint location, GLfloat *v) const
  {
      const VariableLocation &uniformLocation = mState.getUniformLocations()[location];
      const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];
  
      if (uniform.isSampler())
      {
          *v = static_cast<GLfloat>(getSamplerUniformBinding(uniformLocation));
          return;
      }
  
      const GLenum nativeType = gl::VariableComponentType(uniform.type);
      if (nativeType == GL_FLOAT)
      {
          mProgram->getUniformfv(context, location, v);
      }
      else
      {
          getUniformInternal(context, v, location, nativeType, VariableComponentCount(uniform.type));
      }
  }
  
  void Program::getUniformiv(const Context *context, GLint location, GLint *v) const
  {
      const VariableLocation &uniformLocation = mState.getUniformLocations()[location];
      const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];
  
      if (uniform.isSampler())
      {
          *v = static_cast<GLint>(getSamplerUniformBinding(uniformLocation));
          return;
      }
  
      const GLenum nativeType = gl::VariableComponentType(uniform.type);
      if (nativeType == GL_INT || nativeType == GL_BOOL)
      {
          mProgram->getUniformiv(context, location, v);
      }
      else
      {
          getUniformInternal(context, v, location, nativeType, VariableComponentCount(uniform.type));
      }
  }
  
  void Program::getUniformuiv(const Context *context, GLint location, GLuint *v) const
  {
      const VariableLocation &uniformLocation = mState.getUniformLocations()[location];
      const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];
  
      if (uniform.isSampler())
      {
          *v = getSamplerUniformBinding(uniformLocation);
          return;
      }
  
      const GLenum nativeType = VariableComponentType(uniform.type);
      if (nativeType == GL_UNSIGNED_INT)
      {
          mProgram->getUniformuiv(context, location, v);
      }
      else
      {
          getUniformInternal(context, v, location, nativeType, VariableComponentCount(uniform.type));
      }
  }
  
  void Program::flagForDeletion()
  {
      mDeleteStatus = true;
  }
  
  bool Program::isFlaggedForDeletion() const
  {
      return mDeleteStatus;
  }
  
  void Program::validate(const Caps &caps)
  {
      mInfoLog.reset();
  
      if (mLinked)
      {
          mValidated = ConvertToBool(mProgram->validate(caps, &mInfoLog));
      }
      else
      {
          mInfoLog << "Program has not been successfully linked.";
      }
  }
  
  bool Program::validateSamplers(InfoLog *infoLog, const Caps &caps)
  {
      // Skip cache if we're using an infolog, so we get the full error.
      // Also skip the cache if the sample mapping has changed, or if we haven't ever validated.
      if (infoLog == nullptr && mCachedValidateSamplersResult.valid())
      {
          return mCachedValidateSamplersResult.value();
      }
  
      if (mTextureUnitTypesCache.empty())
      {
          mTextureUnitTypesCache.resize(caps.maxCombinedTextureImageUnits, TextureType::InvalidEnum);
      }
      else
      {
          std::fill(mTextureUnitTypesCache.begin(), mTextureUnitTypesCache.end(),
                    TextureType::InvalidEnum);
      }
  
      // if any two active samplers in a program are of different types, but refer to the same
      // texture image unit, and this is the current program, then ValidateProgram will fail, and
      // DrawArrays and DrawElements will issue the INVALID_OPERATION error.
      for (const auto &samplerBinding : mState.mSamplerBindings)
      {
          if (samplerBinding.unreferenced)
              continue;
  
          TextureType textureType = samplerBinding.textureType;
  
          for (GLuint textureUnit : samplerBinding.boundTextureUnits)
          {
              if (textureUnit >= caps.maxCombinedTextureImageUnits)
              {
                  if (infoLog)
                  {
                      (*infoLog) << "Sampler uniform (" << textureUnit
                                 << ") exceeds GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS ("
                                 << caps.maxCombinedTextureImageUnits << ")";
                  }
  
                  mCachedValidateSamplersResult = false;
                  return false;
              }
  
              if (mTextureUnitTypesCache[textureUnit] != TextureType::InvalidEnum)
              {
                  if (textureType != mTextureUnitTypesCache[textureUnit])
                  {
                      if (infoLog)
                      {
                          (*infoLog) << "Samplers of conflicting types refer to the same texture "
                                        "image unit ("
                                     << textureUnit << ").";
                      }
  
                      mCachedValidateSamplersResult = false;
                      return false;
                  }
              }
              else
              {
                  mTextureUnitTypesCache[textureUnit] = textureType;
              }
          }
      }
  
      mCachedValidateSamplersResult = true;
      return true;
  }
  
  bool Program::isValidated() const
  {
      return mValidated;
  }
  
  GLuint Program::getActiveUniformBlockCount() const
  {
      return static_cast<GLuint>(mState.mUniformBlocks.size());
  }
  
  GLuint Program::getActiveAtomicCounterBufferCount() const
  {
      return static_cast<GLuint>(mState.mAtomicCounterBuffers.size());
  }
  
  GLuint Program::getActiveShaderStorageBlockCount() const
  {
      return static_cast<GLuint>(mState.mShaderStorageBlocks.size());
  }
  
  void Program::getActiveUniformBlockName(const GLuint blockIndex,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLchar *blockName) const
  {
      GetInterfaceBlockName(blockIndex, mState.mUniformBlocks, bufSize, length, blockName);
  }
  
  void Program::getActiveShaderStorageBlockName(const GLuint blockIndex,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLchar *blockName) const
  {
  
      GetInterfaceBlockName(blockIndex, mState.mShaderStorageBlocks, 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
  {
      return getActiveInterfaceBlockMaxNameLength(mState.mUniformBlocks);
  }
  
  GLint Program::getActiveShaderStorageBlockMaxNameLength() const
  {
      return getActiveInterfaceBlockMaxNameLength(mState.mShaderStorageBlocks);
  }
  
  GLuint Program::getUniformBlockIndex(const std::string &name) const
  {
      return GetInterfaceBlockIndex(mState.mUniformBlocks, name);
  }
  
  GLuint Program::getShaderStorageBlockIndex(const std::string &name) const
  {
      return GetInterfaceBlockIndex(mState.mShaderStorageBlocks, name);
  }
  
  const InterfaceBlock &Program::getUniformBlockByIndex(GLuint index) const
  {
      ASSERT(index < static_cast<GLuint>(mState.mUniformBlocks.size()));
      return mState.mUniformBlocks[index];
  }
  
  const InterfaceBlock &Program::getShaderStorageBlockByIndex(GLuint index) const
  {
      ASSERT(index < static_cast<GLuint>(mState.mShaderStorageBlocks.size()));
      return mState.mShaderStorageBlocks[index];
  }
  
  void Program::bindUniformBlock(GLuint uniformBlockIndex, GLuint uniformBlockBinding)
  {
      mState.mUniformBlocks[uniformBlockIndex].binding = uniformBlockBinding;
      mState.mActiveUniformBlockBindings.set(uniformBlockIndex, uniformBlockBinding != 0);
      mProgram->setUniformBlockBinding(uniformBlockIndex, uniformBlockBinding);
  }
  
  GLuint Program::getUniformBlockBinding(GLuint uniformBlockIndex) const
  {
      return mState.getUniformBlockBinding(uniformBlockIndex);
  }
  
  GLuint Program::getShaderStorageBlockBinding(GLuint shaderStorageBlockIndex) const
  {
      return mState.getShaderStorageBlockBinding(shaderStorageBlockIndex);
  }
  
  void Program::setTransformFeedbackVaryings(GLsizei count,
                                             const GLchar *const *varyings,
                                             GLenum bufferMode)
  {
      mState.mTransformFeedbackVaryingNames.resize(count);
      for (GLsizei i = 0; i < count; i++)
      {
          mState.mTransformFeedbackVaryingNames[i] = varyings[i];
      }
  
      mState.mTransformFeedbackBufferMode = bufferMode;
  }
  
  void Program::getTransformFeedbackVarying(GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLsizei *size,
                                            GLenum *type,
                                            GLchar *name) const
  {
      if (mLinked)
      {
          ASSERT(index < mState.mLinkedTransformFeedbackVaryings.size());
          const auto &var     = mState.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
  {
      if (mLinked)
      {
          return static_cast<GLsizei>(mState.mLinkedTransformFeedbackVaryings.size());
      }
      else
      {
          return 0;
      }
  }
  
  GLsizei Program::getTransformFeedbackVaryingMaxLength() const
  {
      if (mLinked)
      {
          GLsizei maxSize = 0;
          for (const auto &var : mState.mLinkedTransformFeedbackVaryings)
          {
              maxSize =
                  std::max(maxSize, static_cast<GLsizei>(var.nameWithArrayIndex().length() + 1));
          }
  
          return maxSize;
      }
      else
      {
          return 0;
      }
  }
  
  GLenum Program::getTransformFeedbackBufferMode() const
  {
      return mState.mTransformFeedbackBufferMode;
  }
  
  bool Program::linkValidateShaders(const Context *context, InfoLog &infoLog)
  {
      Shader *vertexShader   = mState.mAttachedShaders[ShaderType::Vertex];
      Shader *fragmentShader = mState.mAttachedShaders[ShaderType::Fragment];
      Shader *computeShader  = mState.mAttachedShaders[ShaderType::Compute];
      Shader *geometryShader = mState.mAttachedShaders[ShaderType::Geometry];
  
      bool isComputeShaderAttached = (computeShader != nullptr);
      bool isGraphicsShaderAttached =
          (vertexShader != nullptr || fragmentShader != nullptr || geometryShader != nullptr);
      // 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 == true && isGraphicsShaderAttached == true)
      {
          infoLog << "Both compute and graphics shaders are attached to the same program.";
          return false;
      }
  
      if (computeShader)
      {
          if (!computeShader->isCompiled(context))
          {
              infoLog << "Attached compute shader is not compiled.";
              return false;
          }
          ASSERT(computeShader->getType() == ShaderType::Compute);
  
          mState.mComputeShaderLocalSize = computeShader->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 (!fragmentShader || !fragmentShader->isCompiled(context))
          {
              infoLog << "No compiled fragment shader when at least one graphics shader is attached.";
              return false;
          }
          ASSERT(fragmentShader->getType() == ShaderType::Fragment);
  
          if (!vertexShader || !vertexShader->isCompiled(context))
          {
              infoLog << "No compiled vertex shader when at least one graphics shader is attached.";
              return false;
          }
          ASSERT(vertexShader->getType() == ShaderType::Vertex);
  
          int vertexShaderVersion = vertexShader->getShaderVersion(context);
          if (fragmentShader->getShaderVersion(context) != vertexShaderVersion)
          {
              infoLog << "Fragment shader version does not match vertex shader version.";
              return false;
          }
  
          if (geometryShader)
          {
              // [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.
              if (!geometryShader->isCompiled(context))
              {
                  infoLog << "The attached geometry shader isn't compiled.";
                  return false;
              }
  
              if (geometryShader->getShaderVersion(context) != vertexShaderVersion)
              {
                  mInfoLog << "Geometry shader version does not match vertex shader version.";
                  return false;
              }
              ASSERT(geometryShader->getType() == ShaderType::Geometry);
  
              Optional<PrimitiveMode> inputPrimitive =
                  geometryShader->getGeometryShaderInputPrimitiveType(context);
              if (!inputPrimitive.valid())
              {
                  mInfoLog << "Input primitive type is not specified in the geometry shader.";
                  return false;
              }
  
              Optional<PrimitiveMode> outputPrimitive =
                  geometryShader->getGeometryShaderOutputPrimitiveType(context);
              if (!outputPrimitive.valid())
              {
                  mInfoLog << "Output primitive type is not specified in the geometry shader.";
                  return false;
              }
  
              Optional<GLint> maxVertices = geometryShader->getGeometryShaderMaxVertices(context);
              if (!maxVertices.valid())
              {
                  mInfoLog << "'max_vertices' is not specified in the geometry shader.";
                  return false;
              }
  
              mState.mGeometryShaderInputPrimitiveType  = inputPrimitive.value();
              mState.mGeometryShaderOutputPrimitiveType = outputPrimitive.value();
              mState.mGeometryShaderMaxVertices         = maxVertices.value();
              mState.mGeometryShaderInvocations =
                  geometryShader->getGeometryShaderInvocations(context);
          }
      }
  
      return true;
  }
  
  GLuint Program::getTransformFeedbackVaryingResourceIndex(const GLchar *name) const
  {
      for (GLuint tfIndex = 0; tfIndex < mState.mLinkedTransformFeedbackVaryings.size(); ++tfIndex)
      {
          const auto &tf = mState.mLinkedTransformFeedbackVaryings[tfIndex];
          if (tf.nameWithArrayIndex() == name)
          {
              return tfIndex;
          }
      }
      return GL_INVALID_INDEX;
  }
  
  const TransformFeedbackVarying &Program::getTransformFeedbackVaryingResource(GLuint index) const
  {
      ASSERT(index < mState.mLinkedTransformFeedbackVaryings.size());
      return mState.mLinkedTransformFeedbackVaryings[index];
  }
  
  bool Program::linkVaryings(const Context *context, InfoLog &infoLog) const
  {
      Shader *previousShader = nullptr;
      for (ShaderType shaderType : kAllGraphicsShaderTypes)
      {
          Shader *currentShader = mState.mAttachedShaders[shaderType];
          if (!currentShader)
          {
              continue;
          }
  
          if (previousShader)
          {
              if (!linkValidateShaderInterfaceMatching(context, previousShader, currentShader,
                                                       infoLog))
              {
                  return false;
              }
          }
          previousShader = currentShader;
      }
  
      if (!linkValidateBuiltInVaryings(context, infoLog))
      {
          return false;
      }
  
      if (!linkValidateFragmentInputBindings(context, infoLog))
      {
          return false;
      }
  
      return true;
  }
  
  // [OpenGL ES 3.1] Chapter 7.4.1 "Shader Interface Matchining" Page 91
  // TODO(jiawei.shao@intel.com): add validation on input/output blocks matching
  bool Program::linkValidateShaderInterfaceMatching(const Context *context,
                                                    gl::Shader *generatingShader,
                                                    gl::Shader *consumingShader,
                                                    gl::InfoLog &infoLog) const
  {
      ASSERT(generatingShader->getShaderVersion(context) ==
             consumingShader->getShaderVersion(context));
  
      const std::vector<sh::Varying> &outputVaryings = generatingShader->getOutputVaryings(context);
      const std::vector<sh::Varying> &inputVaryings  = consumingShader->getInputVaryings(context);
  
      bool validateGeometryShaderInputs = consumingShader->getType() == ShaderType::Geometry;
  
      for (const sh::Varying &input : inputVaryings)
      {
          bool matched = false;
  
          // Built-in varyings obey special rules
          if (input.isBuiltIn())
          {
              continue;
          }
  
          for (const sh::Varying &output : outputVaryings)
          {
              if (input.name == output.name)
              {
                  ASSERT(!output.isBuiltIn());
  
                  std::string mismatchedStructFieldName;
                  LinkMismatchError linkError =
                      LinkValidateVaryings(output, input, generatingShader->getShaderVersion(context),
                                           validateGeometryShaderInputs, &mismatchedStructFieldName);
                  if (linkError != LinkMismatchError::NO_MISMATCH)
                  {
                      LogLinkMismatch(infoLog, input.name, "varying", linkError,
                                      mismatchedStructFieldName, generatingShader->getType(),
                                      consumingShader->getType());
                      return false;
                  }
  
                  matched = true;
                  break;
              }
          }
  
          // We permit unmatched, unreferenced varyings. Note that this specifically depends on
          // whether the input is statically used - a statically used input should fail this test even
          // if it is not active. GLSL ES 3.00.6 section 4.3.10.
          if (!matched && input.staticUse)
          {
              infoLog << GetShaderTypeString(consumingShader->getType()) << " varying " << input.name
                      << " does not match any " << GetShaderTypeString(generatingShader->getType())
                      << " varying";
              return false;
          }
      }
  
      // TODO(jmadill): verify no unmatched output varyings?
  
      return true;
  }
  
  bool Program::linkValidateFragmentInputBindings(const Context *context, gl::InfoLog &infoLog) const
  {
      ASSERT(mState.mAttachedShaders[ShaderType::Fragment]);
  
      std::map<GLuint, std::string> staticFragmentInputLocations;
  
      const std::vector<sh::Varying> &fragmentInputVaryings =
          mState.mAttachedShaders[ShaderType::Fragment]->getInputVaryings(context);
      for (const sh::Varying &input : fragmentInputVaryings)
      {
          if (input.isBuiltIn() || !input.staticUse)
          {
              continue;
          }
  
          const auto inputBinding = mFragmentInputBindings.getBinding(input.name);
          if (inputBinding == -1)
              continue;
  
          const auto it = staticFragmentInputLocations.find(inputBinding);
          if (it == std::end(staticFragmentInputLocations))
          {
              staticFragmentInputLocations.insert(std::make_pair(inputBinding, input.name));
          }
          else
          {
              infoLog << "Binding for fragment input " << input.name << " conflicts with "
                      << it->second;
              return false;
          }
      }
  
      return true;
  }
  
  bool Program::linkUniforms(const Context *context,
                             InfoLog &infoLog,
                             const ProgramBindings &uniformLocationBindings,
                             GLuint *combinedImageUniformsCount,
                             std::vector<UnusedUniform> *unusedUniforms)
  {
      UniformLinker linker(mState);
      if (!linker.link(context, infoLog, uniformLocationBindings))
      {
          return false;
      }
  
      linker.getResults(&mState.mUniforms, unusedUniforms, &mState.mUniformLocations);
  
      linkSamplerAndImageBindings(combinedImageUniformsCount);
  
      if (!linkAtomicCounterBuffers())
      {
          return false;
      }
  
      return true;
  }
  
  void Program::linkSamplerAndImageBindings(GLuint *combinedImageUniforms)
  {
      ASSERT(combinedImageUniforms);
  
      unsigned int high = static_cast<unsigned int>(mState.mUniforms.size());
      unsigned int low  = high;
  
      for (auto counterIter = mState.mUniforms.rbegin();
           counterIter != mState.mUniforms.rend() && counterIter->isAtomicCounter(); ++counterIter)
      {
          --low;
      }
  
      mState.mAtomicCounterUniformRange = RangeUI(low, high);
  
      high = low;
  
      for (auto imageIter = mState.mUniforms.rbegin();
           imageIter != mState.mUniforms.rend() && imageIter->isImage(); ++imageIter)
      {
          --low;
      }
  
      mState.mImageUniformRange = RangeUI(low, high);
      *combinedImageUniforms    = 0u;
      // If uniform is a image type, insert it into the mImageBindings array.
      for (unsigned int imageIndex : mState.mImageUniformRange)
      {
          // ES3.1 (section 7.6.1) and GLSL ES3.1 (section 4.4.5), Uniform*i{v} commands
          // cannot load values into a uniform defined as an image. if declare without a
          // binding qualifier, any uniform image variable (include all elements of
          // unbound image array) shoud be bound to unit zero.
          auto &imageUniform = mState.mUniforms[imageIndex];
          if (imageUniform.binding == -1)
          {
              mState.mImageBindings.emplace_back(
                  ImageBinding(imageUniform.getBasicTypeElementCount()));
          }
          else
          {
              mState.mImageBindings.emplace_back(
                  ImageBinding(imageUniform.binding, imageUniform.getBasicTypeElementCount()));
          }
  
          GLuint arraySize = imageUniform.isArray() ? imageUniform.arraySizes[0] : 1u;
          *combinedImageUniforms += imageUniform.activeShaderCount() * arraySize;
      }
  
      high = low;
  
      for (auto samplerIter = mState.mUniforms.rbegin() + mState.mImageUniformRange.length();
           samplerIter != mState.mUniforms.rend() && samplerIter->isSampler(); ++samplerIter)
      {
          --low;
      }
  
      mState.mSamplerUniformRange = RangeUI(low, high);
  
      // If uniform is a sampler type, insert it into the mSamplerBindings array.
      for (unsigned int samplerIndex : mState.mSamplerUniformRange)
      {
          const auto &samplerUniform = mState.mUniforms[samplerIndex];
          TextureType textureType    = SamplerTypeToTextureType(samplerUniform.type);
          mState.mSamplerBindings.emplace_back(
              SamplerBinding(textureType, samplerUniform.getBasicTypeElementCount(), false));
      }
  }
  
  bool Program::linkAtomicCounterBuffers()
  {
      for (unsigned int index : mState.mAtomicCounterUniformRange)
      {
          auto &uniform                      = mState.mUniforms[index];
          uniform.blockInfo.offset           = uniform.offset;
          uniform.blockInfo.arrayStride      = (uniform.isArray() ? 4 : 0);
          uniform.blockInfo.matrixStride     = 0;
          uniform.blockInfo.isRowMajorMatrix = false;
  
          bool found = false;
          for (unsigned int bufferIndex = 0; bufferIndex < mState.mAtomicCounterBuffers.size();
               ++bufferIndex)
          {
              auto &buffer = mState.mAtomicCounterBuffers[bufferIndex];
              if (buffer.binding == uniform.binding)
              {
                  buffer.memberIndexes.push_back(index);
                  uniform.bufferIndex = bufferIndex;
                  found               = true;
                  buffer.unionReferencesWith(uniform);
                  break;
              }
          }
          if (!found)
          {
              AtomicCounterBuffer atomicCounterBuffer;
              atomicCounterBuffer.binding = uniform.binding;
              atomicCounterBuffer.memberIndexes.push_back(index);
              atomicCounterBuffer.unionReferencesWith(uniform);
              mState.mAtomicCounterBuffers.push_back(atomicCounterBuffer);
              uniform.bufferIndex = static_cast<int>(mState.mAtomicCounterBuffers.size() - 1);
          }
      }
      // TODO(jie.a.chen@intel.com): Count each atomic counter buffer to validate against
      // gl_Max[Vertex|Fragment|Compute|Geometry|Combined]AtomicCounterBuffers.
  
      return true;
  }
  
  // Assigns locations to all attributes from the bindings and program locations.
  bool Program::linkAttributes(const Context *context, InfoLog &infoLog)
  {
      const ContextState &data = context->getContextState();
      Shader *vertexShader     = mState.getAttachedShader(ShaderType::Vertex);
  
      int shaderVersion = vertexShader->getShaderVersion(context);
  
      unsigned int usedLocations = 0;
      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.mAttributes = vertexShader->getAllAttributes(context);
      }
      else
      {
          // In GLSL ES 1.00.17 we only do aliasing checks for active attributes.
          mState.mAttributes = vertexShader->getActiveAttributes(context);
      }
      GLuint maxAttribs = data.getCaps().maxVertexAttributes;
  
      // TODO(jmadill): handle aliasing robustly
      if (mState.mAttributes.size() > maxAttribs)
      {
          infoLog << "Too many vertex attributes.";
          return false;
      }
  
      std::vector<sh::Attribute *> usedAttribMap(maxAttribs, nullptr);
  
      // Assign locations to attributes that have a binding location and check for attribute aliasing.
      for (sh::Attribute &attribute : mState.mAttributes)
      {
          // 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.name);
          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.
                  if (linkedAttribute)
                  {
                      // TODO(jmadill): fix aliasing on ES2
                      // if (shaderVersion >= 300 && !webgl)
                      {
                          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::Attribute &attribute : mState.mAttributes)
      {
          // 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.mAttributesTypeMask.none());
      ASSERT(mState.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.mAttributes.begin();
               attributeIter != mState.mAttributes.end();)
          {
              if (attributeIter->active)
              {
                  ++attributeIter;
              }
              else
              {
                  attributeIter = mState.mAttributes.erase(attributeIter);
              }
          }
      }
  
      for (const sh::Attribute &attribute : mState.mAttributes)
      {
          ASSERT(attribute.active);
          ASSERT(attribute.location != -1);
          unsigned int regs = static_cast<unsigned int>(VariableRegisterCount(attribute.type));
  
          for (unsigned int r = 0; r < regs; r++)
          {
              unsigned int location = static_cast<unsigned int>(attribute.location) + r;
              mState.mActiveAttribLocationsMask.set(location);
              mState.mMaxActiveAttribLocation =
                  std::max(mState.mMaxActiveAttribLocation, location + 1);
  
              // gl_VertexID and gl_InstanceID are active attributes but don't have a bound attribute.
              if (!attribute.isBuiltIn())
              {
                  mState.mAttributesTypeMask.setIndex(VariableComponentType(attribute.type),
                                                      location);
                  mState.mAttributesMask.set(location);
              }
          }
      }
  
      return true;
  }
  
  bool Program::linkInterfaceBlocks(const Context *context,
                                    InfoLog &infoLog,
                                    GLuint *combinedShaderStorageBlocksCount)
  {
      ASSERT(combinedShaderStorageBlocksCount);
  
      const auto &caps = context->getCaps();
  
      GLuint combinedUniformBlocksCount                                         = 0u;
      GLuint numShadersHasUniformBlocks                                         = 0u;
      ShaderMap<const std::vector<sh::InterfaceBlock> *> allShaderUniformBlocks = {};
      for (ShaderType shaderType : AllShaderTypes())
      {
          Shader *shader = mState.mAttachedShaders[shaderType];
          if (!shader)
          {
              continue;
          }
  
          const auto &uniformBlocks = shader->getUniformBlocks(context);
          if (!uniformBlocks.empty())
          {
              if (!ValidateInterfaceBlocksCount(
                      caps.maxShaderUniformBlocks[shaderType], uniformBlocks, shaderType,
                      sh::BlockType::BLOCK_UNIFORM, &combinedUniformBlocksCount, infoLog))
              {
                  return false;
              }
  
              allShaderUniformBlocks[shaderType] = &uniformBlocks;
              ++numShadersHasUniformBlocks;
          }
      }
  
      if (combinedUniformBlocksCount > caps.maxCombinedUniformBlocks)
      {
          infoLog << "The sum of the number of active uniform blocks exceeds "
                     "MAX_COMBINED_UNIFORM_BLOCKS ("
                  << caps.maxCombinedUniformBlocks << ").";
          return false;
      }
  
      bool webglCompatibility = context->getExtensions().webglCompatibility;
      if (!ValidateInterfaceBlocksMatch(numShadersHasUniformBlocks, allShaderUniformBlocks, infoLog,
                                        webglCompatibility))
      {
          return false;
      }
  
      if (context->getClientVersion() >= Version(3, 1))
      {
          *combinedShaderStorageBlocksCount                                         = 0u;
          GLuint numShadersHasShaderStorageBlocks                                   = 0u;
          ShaderMap<const std::vector<sh::InterfaceBlock> *> allShaderStorageBlocks = {};
          for (ShaderType shaderType : AllShaderTypes())
          {
              Shader *shader = mState.mAttachedShaders[shaderType];
              if (!shader)
              {
                  continue;
              }
  
              const auto &shaderStorageBlocks = shader->getShaderStorageBlocks(context);
              if (!shaderStorageBlocks.empty())
              {
                  if (!ValidateInterfaceBlocksCount(
                          caps.maxShaderStorageBlocks[shaderType], shaderStorageBlocks, shaderType,
                          sh::BlockType::BLOCK_BUFFER, combinedShaderStorageBlocksCount, infoLog))
                  {
                      return false;
                  }
  
                  allShaderStorageBlocks[shaderType] = &shaderStorageBlocks;
                  ++numShadersHasShaderStorageBlocks;
              }
          }
  
          if (*combinedShaderStorageBlocksCount > caps.maxCombinedShaderStorageBlocks)
          {
              infoLog << "The sum of the number of active shader storage blocks exceeds "
                         "MAX_COMBINED_SHADER_STORAGE_BLOCKS ("
                      << caps.maxCombinedShaderStorageBlocks << ").";
              return false;
          }
  
          if (!ValidateInterfaceBlocksMatch(numShadersHasShaderStorageBlocks, allShaderStorageBlocks,
                                            infoLog, webglCompatibility))
          {
              return false;
          }
      }
  
      return true;
  }
  
  LinkMismatchError Program::LinkValidateVariablesBase(const sh::ShaderVariable &variable1,
                                                       const sh::ShaderVariable &variable2,
                                                       bool validatePrecision,
                                                       bool validateArraySize,
                                                       std::string *mismatchedStructOrBlockMemberName)
  {
      if (variable1.type != variable2.type)
      {
          return LinkMismatchError::TYPE_MISMATCH;
      }
      if (validateArraySize && variable1.arraySizes != variable2.arraySizes)
      {
          return LinkMismatchError::ARRAY_SIZE_MISMATCH;
      }
      if (validatePrecision && variable1.precision != variable2.precision)
      {
          return LinkMismatchError::PRECISION_MISMATCH;
      }
      if (variable1.structName != variable2.structName)
      {
          return LinkMismatchError::STRUCT_NAME_MISMATCH;
      }
  
      if (variable1.fields.size() != variable2.fields.size())
      {
          return LinkMismatchError::FIELD_NUMBER_MISMATCH;
      }
      const unsigned int numMembers = static_cast<unsigned int>(variable1.fields.size());
      for (unsigned int memberIndex = 0; memberIndex < numMembers; memberIndex++)
      {
          const sh::ShaderVariable &member1 = variable1.fields[memberIndex];
          const sh::ShaderVariable &member2 = variable2.fields[memberIndex];
  
          if (member1.name != member2.name)
          {
              return LinkMismatchError::FIELD_NAME_MISMATCH;
          }
  
          LinkMismatchError linkErrorOnField = LinkValidateVariablesBase(
              member1, member2, validatePrecision, true, mismatchedStructOrBlockMemberName);
          if (linkErrorOnField != LinkMismatchError::NO_MISMATCH)
          {
              AddParentPrefix(member1.name, mismatchedStructOrBlockMemberName);
              return linkErrorOnField;
          }
      }
  
      return LinkMismatchError::NO_MISMATCH;
  }
  
  LinkMismatchError Program::LinkValidateVaryings(const sh::Varying &outputVarying,
                                                  const sh::Varying &inputVarying,
                                                  int shaderVersion,
                                                  bool validateGeometryShaderInputVarying,
                                                  std::string *mismatchedStructFieldName)
  {
      if (validateGeometryShaderInputVarying)
      {
          // [GL_EXT_geometry_shader] Section 11.1gs.4.3:
          // The OpenGL ES Shading Language doesn't support multi-dimensional arrays as shader inputs
          // or outputs.
          ASSERT(inputVarying.arraySizes.size() == 1u);
  
          // Geometry shader input varyings are not treated as arrays, so a vertex array output
          // varying cannot match a geometry shader input varying.
          // [GL_EXT_geometry_shader] Section 7.4.1:
          // Geometry shader per-vertex input variables and blocks are required to be declared as
          // arrays, with each element representing input or output values for a single vertex of a
          // multi-vertex primitive. For the purposes of interface matching, such variables and blocks
          // are treated as though they were not declared as arrays.
          if (outputVarying.isArray())
          {
              return LinkMismatchError::ARRAY_SIZE_MISMATCH;
          }
      }
  
      // Skip the validation on the array sizes between a vertex output varying and a geometry input
      // varying as it has been done before.
      LinkMismatchError linkError =
          LinkValidateVariablesBase(outputVarying, inputVarying, false,
                                    !validateGeometryShaderInputVarying, mismatchedStructFieldName);
      if (linkError != LinkMismatchError::NO_MISMATCH)
      {
          return linkError;
      }
  
      if (!sh::InterpolationTypesMatch(outputVarying.interpolation, inputVarying.interpolation))
      {
          return LinkMismatchError::INTERPOLATION_TYPE_MISMATCH;
      }
  
      if (shaderVersion == 100 && outputVarying.isInvariant != inputVarying.isInvariant)
      {
          return LinkMismatchError::INVARIANCE_MISMATCH;
      }
  
      return LinkMismatchError::NO_MISMATCH;
  }
  
  bool Program::linkValidateBuiltInVaryings(const Context *context, InfoLog &infoLog) const
  {
      Shader *vertexShader         = mState.mAttachedShaders[ShaderType::Vertex];
      Shader *fragmentShader       = mState.mAttachedShaders[ShaderType::Fragment];
      const auto &vertexVaryings   = vertexShader->getOutputVaryings(context);
      const auto &fragmentVaryings = fragmentShader->getInputVaryings(context);
      int shaderVersion            = vertexShader->getShaderVersion(context);
  
      if (shaderVersion != 100)
      {
          // Only ESSL 1.0 has restrictions on matching input and output invariance
          return true;
      }
  
      bool glPositionIsInvariant   = false;
      bool glPointSizeIsInvariant  = false;
      bool glFragCoordIsInvariant  = false;
      bool glPointCoordIsInvariant = false;
  
      for (const sh::Varying &varying : vertexVaryings)
      {
          if (!varying.isBuiltIn())
          {
              continue;
          }
          if (varying.name.compare("gl_Position") == 0)
          {
              glPositionIsInvariant = varying.isInvariant;
          }
          else if (varying.name.compare("gl_PointSize") == 0)
          {
              glPointSizeIsInvariant = varying.isInvariant;
          }
      }
  
      for (const sh::Varying &varying : fragmentVaryings)
      {
          if (!varying.isBuiltIn())
          {
              continue;
          }
          if (varying.name.compare("gl_FragCoord") == 0)
          {
              glFragCoordIsInvariant = varying.isInvariant;
          }
          else if (varying.name.compare("gl_PointCoord") == 0)
          {
              glPointCoordIsInvariant = varying.isInvariant;
          }
      }
  
      // There is some ambiguity in ESSL 1.00.17 paragraph 4.6.4 interpretation,
      // for example, https://cvs.khronos.org/bugzilla/show_bug.cgi?id=13842.
      // Not requiring invariance to match is supported by:
      // dEQP, WebGL CTS, Nexus 5X GLES
      if (glFragCoordIsInvariant && !glPositionIsInvariant)
      {
          infoLog << "gl_FragCoord can only be declared invariant if and only if gl_Position is "
                     "declared invariant.";
          return false;
      }
      if (glPointCoordIsInvariant && !glPointSizeIsInvariant)
      {
          infoLog << "gl_PointCoord can only be declared invariant if and only if gl_PointSize is "
                     "declared invariant.";
          return false;
      }
  
      return true;
  }
  
  bool Program::linkValidateTransformFeedback(const gl::Context *context,
                                              InfoLog &infoLog,
                                              const ProgramMergedVaryings &varyings,
                                              const Caps &caps) const
  {
  
      // Validate the tf names regardless of the actual program varyings.
      std::set<std::string> uniqueNames;
      for (const std::string &tfVaryingName : mState.mTransformFeedbackVaryingNames)
      {
          if (context->getClientVersion() < Version(3, 1) &&
              tfVaryingName.find('[') != std::string::npos)
          {
              infoLog << "Capture of array elements is undefined and not supported.";
              return false;
          }
          if (context->getClientVersion() >= Version(3, 1))
          {
              if (IncludeSameArrayElement(uniqueNames, tfVaryingName))
              {
                  infoLog << "Two transform feedback varyings include the same array element ("
                          << tfVaryingName << ").";
                  return false;
              }
          }
          else
          {
              if (uniqueNames.count(tfVaryingName) > 0)
              {
                  infoLog << "Two transform feedback varyings specify the same output variable ("
                          << tfVaryingName << ").";
                  return false;
              }
          }
          uniqueNames.insert(tfVaryingName);
      }
  
      // Validate against program varyings.
      size_t totalComponents = 0;
      for (const std::string &tfVaryingName : mState.mTransformFeedbackVaryingNames)
      {
          std::vector<unsigned int> subscripts;
          std::string baseName = ParseResourceName(tfVaryingName, &subscripts);
  
          const sh::ShaderVariable *var = FindVaryingOrField(varyings, baseName);
          if (var == nullptr)
          {
              infoLog << "Transform feedback varying " << tfVaryingName
                      << " does not exist in the vertex shader.";
              return false;
          }
  
          // Validate the matching variable.
          if (var->isStruct())
          {
              infoLog << "Struct cannot be captured directly (" << baseName << ").";
              return false;
          }
  
          size_t elementCount   = 0;
          size_t componentCount = 0;
  
          if (var->isArray())
          {
              if (context->getClientVersion() < Version(3, 1))
              {
                  infoLog << "Capture of arrays is undefined and not supported.";
                  return false;
              }
  
              // GLSL ES 3.10 section 4.3.6: A vertex output can't be an array of arrays.
              ASSERT(!var->isArrayOfArrays());
  
              if (!subscripts.empty() && subscripts[0] >= var->getOutermostArraySize())
              {
                  infoLog << "Cannot capture outbound array element '" << tfVaryingName << "'.";
                  return false;
              }
              elementCount = (subscripts.empty() ? var->getOutermostArraySize() : 1);
          }
          else
          {
              if (!subscripts.empty())
              {
                  infoLog << "Varying '" << baseName
                          << "' is not an array to be captured by element.";
                  return false;
              }
              elementCount = 1;
          }
  
          // TODO(jmadill): Investigate implementation limits on D3D11
          componentCount = VariableComponentCount(var->type) * elementCount;
          if (mState.mTransformFeedbackBufferMode == GL_SEPARATE_ATTRIBS &&
              componentCount > caps.maxTransformFeedbackSeparateComponents)
          {
              infoLog << "Transform feedback varying " << tfVaryingName << " components ("
                      << componentCount << ") exceed the maximum separate components ("
                      << caps.maxTransformFeedbackSeparateComponents << ").";
              return false;
          }
  
          totalComponents += componentCount;
          if (mState.mTransformFeedbackBufferMode == GL_INTERLEAVED_ATTRIBS &&
              totalComponents > caps.maxTransformFeedbackInterleavedComponents)
          {
              infoLog << "Transform feedback varying total components (" << totalComponents
                      << ") exceed the maximum interleaved components ("
                      << caps.maxTransformFeedbackInterleavedComponents << ").";
              return false;
          }
      }
      return true;
  }
  
  bool Program::linkValidateGlobalNames(const Context *context, InfoLog &infoLog) const
  {
      const std::vector<sh::Attribute> &attributes =
          mState.mAttachedShaders[ShaderType::Vertex]->getActiveAttributes(context);
  
      for (const auto &attrib : attributes)
      {
          for (ShaderType shaderType : kAllGraphicsShaderTypes)
          {
              Shader *shader = mState.mAttachedShaders[shaderType];
              if (!shader)
              {
                  continue;
              }
  
              const std::vector<sh::Uniform> &uniforms = shader->getUniforms(context);
              for (const auto &uniform : uniforms)
              {
                  if (uniform.name == attrib.name)
                  {
                      infoLog << "Name conflicts between a uniform and an attribute: " << attrib.name;
                      return false;
                  }
              }
          }
      }
  
      return true;
  }
  
  void Program::gatherTransformFeedbackVaryings(const ProgramMergedVaryings &varyings)
  {
      // Gather the linked varyings that are used for transform feedback, they should all exist.
      mState.mLinkedTransformFeedbackVaryings.clear();
      for (const std::string &tfVaryingName : mState.mTransformFeedbackVaryingNames)
      {
          std::vector<unsigned int> subscripts;
          std::string baseName = ParseResourceName(tfVaryingName, &subscripts);
          size_t subscript     = GL_INVALID_INDEX;
          if (!subscripts.empty())
          {
              subscript = subscripts.back();
          }
          for (const auto &ref : varyings)
          {
              const sh::Varying *varying = ref.second.get();
              if (baseName == varying->name)
              {
                  mState.mLinkedTransformFeedbackVaryings.emplace_back(
                      *varying, static_cast<GLuint>(subscript));
                  break;
              }
              else if (varying->isStruct())
              {
                  const auto *field = FindShaderVarField(*varying, tfVaryingName);
                  if (field != nullptr)
                  {
                      mState.mLinkedTransformFeedbackVaryings.emplace_back(*field, *varying);
                      break;
                  }
              }
          }
      }
      mState.updateTransformFeedbackStrides();
  }
  
  ProgramMergedVaryings Program::getMergedVaryings(const Context *context) const
  {
      ProgramMergedVaryings merged;
  
      for (const sh::Varying &varying :
           mState.mAttachedShaders[ShaderType::Vertex]->getOutputVaryings(context))
      {
          merged[varying.name].vertex = &varying;
      }
  
      for (const sh::Varying &varying :
           mState.mAttachedShaders[ShaderType::Fragment]->getInputVaryings(context))
      {
          merged[varying.name].fragment = &varying;
      }
  
      return merged;
  }
  
  bool Program::linkOutputVariables(const Context *context,
                                    GLuint combinedImageUniformsCount,
                                    GLuint combinedShaderStorageBlocksCount)
  {
      Shader *fragmentShader = mState.mAttachedShaders[ShaderType::Fragment];
      ASSERT(fragmentShader != nullptr);
  
      ASSERT(mState.mOutputVariableTypes.empty());
      ASSERT(mState.mActiveOutputVariables.none());
      ASSERT(mState.mDrawBufferTypeMask.none());
  
      const auto &outputVariables = fragmentShader->getActiveOutputVariables(context);
      // Gather output variable types
      for (const auto &outputVariable : outputVariables)
      {
          if (outputVariable.isBuiltIn() && outputVariable.name != "gl_FragColor" &&
              outputVariable.name != "gl_FragData")
          {
              continue;
          }
  
          unsigned int baseLocation =
              (outputVariable.location == -1 ? 0u
                                             : static_cast<unsigned int>(outputVariable.location));
  
          // GLSL ES 3.10 section 4.3.6: Output variables cannot be arrays of arrays or arrays of
          // structures, so we may use getBasicTypeElementCount().
          unsigned int elementCount = outputVariable.getBasicTypeElementCount();
          for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++)
          {
              const unsigned int location = baseLocation + elementIndex;
              if (location >= mState.mOutputVariableTypes.size())
              {
                  mState.mOutputVariableTypes.resize(location + 1, GL_NONE);
              }
              ASSERT(location < mState.mActiveOutputVariables.size());
              mState.mActiveOutputVariables.set(location);
              mState.mOutputVariableTypes[location] = VariableComponentType(outputVariable.type);
              mState.mDrawBufferTypeMask.setIndex(mState.mOutputVariableTypes[location], location);
          }
      }
  
      if (context->getClientVersion() >= ES_3_1)
      {
          // [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 (combinedImageUniformsCount + combinedShaderStorageBlocksCount +
                  mState.mActiveOutputVariables.count() >
              context->getCaps().maxCombinedShaderOutputResources)
          {
              mInfoLog
                  << "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 false;
          }
      }
  
      // Skip this step for GLES2 shaders.
      if (fragmentShader->getShaderVersion(context) == 100)
          return true;
  
      mState.mOutputVariables = outputVariables;
      // TODO(jmadill): any caps validation here?
  
      for (unsigned int outputVariableIndex = 0; outputVariableIndex < mState.mOutputVariables.size();
           outputVariableIndex++)
      {
          const sh::OutputVariable &outputVariable = mState.mOutputVariables[outputVariableIndex];
  
          if (outputVariable.isArray())
          {
              // We're following the GLES 3.1 November 2016 spec section 7.3.1.1 Naming Active
              // Resources and including [0] at the end of array variable names.
              mState.mOutputVariables[outputVariableIndex].name += "[0]";
              mState.mOutputVariables[outputVariableIndex].mappedName += "[0]";
          }
  
          // Don't store outputs for gl_FragDepth, gl_FragColor, etc.
          if (outputVariable.isBuiltIn())
              continue;
  
          // Since multiple output locations must be specified, use 0 for non-specified locations.
          unsigned int baseLocation =
              (outputVariable.location == -1 ? 0u
                                             : static_cast<unsigned int>(outputVariable.location));
  
          // GLSL ES 3.10 section 4.3.6: Output variables cannot be arrays of arrays or arrays of
          // structures, so we may use getBasicTypeElementCount().
          unsigned int elementCount = outputVariable.getBasicTypeElementCount();
          for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++)
          {
              const unsigned int location = baseLocation + elementIndex;
              if (location >= mState.mOutputLocations.size())
              {
                  mState.mOutputLocations.resize(location + 1);
              }
              ASSERT(!mState.mOutputLocations.at(location).used());
              if (outputVariable.isArray())
              {
                  mState.mOutputLocations[location] =
                      VariableLocation(elementIndex, outputVariableIndex);
              }
              else
              {
                  VariableLocation locationInfo;
                  locationInfo.index                = outputVariableIndex;
                  mState.mOutputLocations[location] = locationInfo;
              }
          }
      }
  
      return true;
  }
  
  void Program::setUniformValuesFromBindingQualifiers()
  {
      for (unsigned int samplerIndex : mState.mSamplerUniformRange)
      {
          const auto &samplerUniform = mState.mUniforms[samplerIndex];
          if (samplerUniform.binding != -1)
          {
              GLint location = getUniformLocation(samplerUniform.name);
              ASSERT(location != -1);
              std::vector<GLint> boundTextureUnits;
              for (unsigned int elementIndex = 0;
                   elementIndex < samplerUniform.getBasicTypeElementCount(); ++elementIndex)
              {
                  boundTextureUnits.push_back(samplerUniform.binding + elementIndex);
              }
              setUniform1iv(location, static_cast<GLsizei>(boundTextureUnits.size()),
                            boundTextureUnits.data());
          }
      }
  }
  
  void Program::initInterfaceBlockBindings()
  {
      // Set initial bindings from shader.
      for (unsigned int blockIndex = 0; blockIndex < mState.mUniformBlocks.size(); blockIndex++)
      {
          InterfaceBlock &uniformBlock = mState.mUniformBlocks[blockIndex];
          bindUniformBlock(blockIndex, uniformBlock.binding);
      }
  }
  
  void Program::updateSamplerUniform(const VariableLocation &locationInfo,
                                     GLsizei clampedCount,
                                     const GLint *v)
  {
      ASSERT(mState.isSamplerUniformIndex(locationInfo.index));
      GLuint samplerIndex = mState.getSamplerIndexFromUniformIndex(locationInfo.index);
      std::vector<GLuint> *boundTextureUnits =
          &mState.mSamplerBindings[samplerIndex].boundTextureUnits;
  
      std::copy(v, v + clampedCount, boundTextureUnits->begin() + locationInfo.arrayIndex);
  
      // Invalidate the validation cache.
      mCachedValidateSamplersResult.reset();
  }
  
  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.mUniforms[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(GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const T *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location];
  
      if (!transpose)
      {
          return clampUniformCount(locationInfo, count, cols * rows, v);
      }
  
      const LinkedUniform &linkedUniform = mState.mUniforms[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,
                                   GLint location,
                                   GLenum nativeType,
                                   int components) const
  {
      switch (nativeType)
      {
          case GL_BOOL:
          {
              GLint tempValue[16] = {0};
              mProgram->getUniformiv(context, location, tempValue);
              UniformStateQueryCastLoop<GLboolean>(
                  dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
              break;
          }
          case GL_INT:
          {
              GLint tempValue[16] = {0};
              mProgram->getUniformiv(context, location, tempValue);
              UniformStateQueryCastLoop<GLint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
                                               components);
              break;
          }
          case GL_UNSIGNED_INT:
          {
              GLuint tempValue[16] = {0};
              mProgram->getUniformuiv(context, location, tempValue);
              UniformStateQueryCastLoop<GLuint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
                                                components);
              break;
          }
          case GL_FLOAT:
          {
              GLfloat tempValue[16] = {0};
              mProgram->getUniformfv(context, location, tempValue);
              UniformStateQueryCastLoop<GLfloat>(
                  dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
              break;
          }
          default:
              UNREACHABLE();
              break;
      }
  }
  
  bool Program::samplesFromTexture(const gl::State &state, GLuint textureID) const
  {
      // Must be called after samplers are validated.
      ASSERT(mCachedValidateSamplersResult.valid() && mCachedValidateSamplersResult.value());
  
      for (const auto &binding : mState.mSamplerBindings)
      {
          TextureType textureType = binding.textureType;
          for (const auto &unit : binding.boundTextureUnits)
          {
              GLenum programTextureID = state.getSamplerTextureId(unit, textureType);
              if (programTextureID == textureID)
              {
                  // TODO(jmadill): Check for appropriate overlap.
                  return true;
              }
          }
      }
  
      return false;
  }
  
  }  // namespace gl