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

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Tim Van Patten
  Date : 2020-06-12 17:09:13
  Hash : 289365fa
  Message : Remove ProgramExecutable::mProgram[Pipeline]State Remove the ProgramExecutable::mProgram[Pipeline]State pointers. Bug: angleproject:4520 Test: Build/CQ Change-Id: I1717e291ff9beec226bd2888e990b27d8078797c Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2243764 Commit-Queue: Tim Van Patten <timvp@google.com> Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com> Reviewed-by: Jamie Madill <jmadill@chromium.org>

• src/libANGLE/Program.cpp

• //
  // Copyright 2002 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // Program.cpp: Implements the gl::Program class. Implements GL program objects
  // and related functionality. [OpenGL ES 2.0.24] section 2.10.3 page 28.
  
  #include "libANGLE/Program.h"
  
  #include <algorithm>
  #include <utility>
  
  #include "common/bitset_utils.h"
  #include "common/debug.h"
  #include "common/platform.h"
  #include "common/string_utils.h"
  #include "common/utilities.h"
  #include "common/version.h"
  #include "compiler/translator/blocklayout.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/ErrorStrings.h"
  #include "libANGLE/MemoryProgramCache.h"
  #include "libANGLE/ProgramLinkedResources.h"
  #include "libANGLE/ResourceManager.h"
  #include "libANGLE/Uniform.h"
  #include "libANGLE/VaryingPacking.h"
  #include "libANGLE/Version.h"
  #include "libANGLE/features.h"
  #include "libANGLE/histogram_macros.h"
  #include "libANGLE/queryconversions.h"
  #include "libANGLE/renderer/GLImplFactory.h"
  #include "libANGLE/renderer/ProgramImpl.h"
  #include "platform/FrontendFeatures.h"
  #include "platform/PlatformMethods.h"
  
  namespace gl
  {
  
  namespace
  {
  
  // This simplified cast function doesn't need to worry about advanced concepts like
  // depth range values, or casting to bool.
  template <typename DestT, typename SrcT>
  DestT UniformStateQueryCast(SrcT value);
  
  // From-Float-To-Integer Casts
  template <>
  GLint UniformStateQueryCast(GLfloat value)
  {
      return clampCast<GLint>(roundf(value));
  }
  
  template <>
  GLuint UniformStateQueryCast(GLfloat value)
  {
      return clampCast<GLuint>(roundf(value));
  }
  
  // From-Integer-to-Integer Casts
  template <>
  GLint UniformStateQueryCast(GLuint value)
  {
      return clampCast<GLint>(value);
  }
  
  template <>
  GLuint UniformStateQueryCast(GLint value)
  {
      return clampCast<GLuint>(value);
  }
  
  // From-Boolean-to-Anything Casts
  template <>
  GLfloat UniformStateQueryCast(GLboolean value)
  {
      return (ConvertToBool(value) ? 1.0f : 0.0f);
  }
  
  template <>
  GLint UniformStateQueryCast(GLboolean value)
  {
      return (ConvertToBool(value) ? 1 : 0);
  }
  
  template <>
  GLuint UniformStateQueryCast(GLboolean value)
  {
      return (ConvertToBool(value) ? 1u : 0u);
  }
  
  // Default to static_cast
  template <typename DestT, typename SrcT>
  DestT UniformStateQueryCast(SrcT value)
  {
      return static_cast<DestT>(value);
  }
  
  template <typename SrcT, typename DestT>
  void UniformStateQueryCastLoop(DestT *dataOut, const uint8_t *srcPointer, int components)
  {
      for (int comp = 0; comp < components; ++comp)
      {
          // We only work with strides of 4 bytes for uniform components. (GLfloat/GLint)
          // Don't use SrcT stride directly since GLboolean has a stride of 1 byte.
          size_t offset               = comp * 4;
          const SrcT *typedSrcPointer = reinterpret_cast<const SrcT *>(&srcPointer[offset]);
          dataOut[comp]               = UniformStateQueryCast<DestT>(*typedSrcPointer);
      }
  }
  
  template <typename VarT>
  GLuint GetResourceIndexFromName(const std::vector<VarT> &list, const std::string &name)
  {
      std::string nameAsArrayName = name + "[0]";
      for (size_t index = 0; index < list.size(); index++)
      {
          const VarT &resource = list[index];
          if (resource.name == name || (resource.isArray() && resource.name == nameAsArrayName))
          {
              return static_cast<GLuint>(index);
          }
      }
  
      return GL_INVALID_INDEX;
  }
  
  GLint GetVariableLocation(const std::vector<sh::ShaderVariable> &list,
                            const std::vector<VariableLocation> &locationList,
                            const std::string &name)
  {
      size_t nameLengthWithoutArrayIndex;
      unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex);
  
      for (size_t location = 0u; location < locationList.size(); ++location)
      {
          const VariableLocation &variableLocation = locationList[location];
          if (!variableLocation.used())
          {
              continue;
          }
  
          const sh::ShaderVariable &variable = list[variableLocation.index];
  
          // Array output variables may be bound out of order, so we need to ensure we only pick the
          // first element if given the base name.
          if ((variable.name == name) && (variableLocation.arrayIndex == 0))
          {
              return static_cast<GLint>(location);
          }
          if (variable.isArray() && variableLocation.arrayIndex == arrayIndex &&
              angle::BeginsWith(variable.name, name, nameLengthWithoutArrayIndex))
          {
              return static_cast<GLint>(location);
          }
      }
  
      return -1;
  }
  
  GLint GetVariableLocation(const std::vector<LinkedUniform> &list,
                            const std::vector<VariableLocation> &locationList,
                            const std::string &name)
  {
      size_t nameLengthWithoutArrayIndex;
      unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex);
  
      for (size_t location = 0u; location < locationList.size(); ++location)
      {
          const VariableLocation &variableLocation = locationList[location];
          if (!variableLocation.used())
          {
              continue;
          }
  
          const LinkedUniform &variable = list[variableLocation.index];
  
          // Array output variables may be bound out of order, so we need to ensure we only pick the
          // first element if given the base name. Uniforms don't allow this behavior and some code
          // seemingly depends on the opposite behavior, so only enable it for output variables.
          if (angle::BeginsWith(variable.name, name) && (variableLocation.arrayIndex == 0))
          {
              if (name.length() == variable.name.length())
              {
                  ASSERT(name == variable.name);
                  // GLES 3.1 November 2016 page 87.
                  // The string exactly matches the name of the active variable.
                  return static_cast<GLint>(location);
              }
              if (name.length() + 3u == variable.name.length() && variable.isArray())
              {
                  ASSERT(name + "[0]" == variable.name);
                  // The string identifies the base name of an active array, where the string would
                  // exactly match the name of the variable if the suffix "[0]" were appended to the
                  // string.
                  return static_cast<GLint>(location);
              }
          }
          if (variable.isArray() && variableLocation.arrayIndex == arrayIndex &&
              nameLengthWithoutArrayIndex + 3u == variable.name.length() &&
              angle::BeginsWith(variable.name, name, nameLengthWithoutArrayIndex))
          {
              ASSERT(name.substr(0u, nameLengthWithoutArrayIndex) + "[0]" == variable.name);
              // The string identifies an active element of the array, where the string ends with the
              // concatenation of the "[" character, an integer (with no "+" sign, extra leading
              // zeroes, or whitespace) identifying an array element, and the "]" character, the
              // integer is less than the number of active elements of the array variable, and where
              // the string would exactly match the enumerated name of the array if the decimal
              // integer were replaced with zero.
              return static_cast<GLint>(location);
          }
      }
  
      return -1;
  }
  
  void CopyStringToBuffer(GLchar *buffer,
                          const std::string &string,
                          GLsizei bufSize,
                          GLsizei *lengthOut)
  {
      ASSERT(bufSize > 0);
      size_t length = std::min<size_t>(bufSize - 1, string.length());
      memcpy(buffer, string.c_str(), length);
      buffer[length] = '\0';
  
      if (lengthOut)
      {
          *lengthOut = static_cast<GLsizei>(length);
      }
  }
  
  bool IncludeSameArrayElement(const std::set<std::string> &nameSet, const std::string &name)
  {
      std::vector<unsigned int> subscripts;
      std::string baseName = ParseResourceName(name, &subscripts);
      for (const std::string &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 ProgramState &state, UniformBlockLinker *blockLinker)
  {
      for (ShaderType shaderType : AllShaderTypes())
      {
          Shader *shader = state.getAttachedShader(shaderType);
          if (shader)
          {
              blockLinker->addShaderBlocks(shaderType, &shader->getUniformBlocks());
          }
      }
  }
  
  void InitShaderStorageBlockLinker(const ProgramState &state, ShaderStorageBlockLinker *blockLinker)
  {
      for (ShaderType shaderType : AllShaderTypes())
      {
          Shader *shader = state.getAttachedShader(shaderType);
          if (shader != nullptr)
          {
              blockLinker->addShaderBlocks(shaderType, &shader->getShaderStorageBlocks());
          }
      }
  }
  
  // Find the matching varying or field by name.
  const sh::ShaderVariable *FindOutputVaryingOrField(const ProgramMergedVaryings &varyings,
                                                     ShaderType stage,
                                                     const std::string &name)
  {
      const sh::ShaderVariable *var = nullptr;
      for (const ProgramVaryingRef &ref : varyings)
      {
          if (ref.frontShaderStage != stage)
          {
              continue;
          }
  
          const sh::ShaderVariable *varying = ref.get(stage);
          if (varying->name == name)
          {
              var = varying;
              break;
          }
          GLuint fieldIndex = 0;
          var               = varying->findField(name, &fieldIndex);
          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 qualifier";
          case LinkMismatchError::INSTANCE_NAME_MISMATCH:
              return "Instance name qualifier";
          case LinkMismatchError::FORMAT_MISMATCH:
              return "Format qualifier";
  
          case LinkMismatchError::LAYOUT_QUALIFIER_MISMATCH:
              return "Layout qualifier";
          case LinkMismatchError::MATRIX_PACKING_MISMATCH:
              return "Matrix Packing";
          default:
              UNREACHABLE();
              return "";
      }
  }
  
  LinkMismatchError LinkValidateInterfaceBlockFields(const sh::ShaderVariable &blockField1,
                                                     const sh::ShaderVariable &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;
      }
      if (interfaceBlock1.instanceName.empty() != interfaceBlock2.instanceName.empty())
      {
          return LinkMismatchError::INSTANCE_NAME_MISMATCH;
      }
      const unsigned int numBlockMembers = static_cast<unsigned int>(interfaceBlock1.fields.size());
      for (unsigned int blockMemberIndex = 0; blockMemberIndex < numBlockMembers; blockMemberIndex++)
      {
          const sh::ShaderVariable &member1 = interfaceBlock1.fields[blockMemberIndex];
          const sh::ShaderVariable &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;
  }
  
  void WriteShaderVariableBuffer(BinaryOutputStream *stream, const ShaderVariableBuffer &var)
  {
      stream->writeInt(var.binding);
      stream->writeInt(var.dataSize);
  
      for (ShaderType shaderType : AllShaderTypes())
      {
          stream->writeInt(var.isActive(shaderType));
      }
  
      stream->writeInt(var.memberIndexes.size());
      for (unsigned int memberCounterIndex : var.memberIndexes)
      {
          stream->writeInt(memberCounterIndex);
      }
  }
  
  void LoadShaderVariableBuffer(BinaryInputStream *stream, ShaderVariableBuffer *var)
  {
      var->binding  = stream->readInt<int>();
      var->dataSize = stream->readInt<unsigned int>();
  
      for (ShaderType shaderType : AllShaderTypes())
      {
          var->setActive(shaderType, stream->readBool());
      }
  
      unsigned int numMembers = stream->readInt<unsigned int>();
      for (unsigned int blockMemberIndex = 0; blockMemberIndex < numMembers; blockMemberIndex++)
      {
          var->memberIndexes.push_back(stream->readInt<unsigned int>());
      }
  }
  
  void WriteBufferVariable(BinaryOutputStream *stream, const BufferVariable &var)
  {
      WriteShaderVar(stream, var);
  
      stream->writeInt(var.bufferIndex);
      WriteBlockMemberInfo(stream, var.blockInfo);
      stream->writeInt(var.topLevelArraySize);
  
      for (ShaderType shaderType : AllShaderTypes())
      {
          stream->writeInt(var.isActive(shaderType));
      }
  }
  
  void LoadBufferVariable(BinaryInputStream *stream, BufferVariable *var)
  {
      LoadShaderVar(stream, var);
  
      var->bufferIndex = stream->readInt<int>();
      LoadBlockMemberInfo(stream, &var->blockInfo);
      var->topLevelArraySize = stream->readInt<int>();
  
      for (ShaderType shaderType : AllShaderTypes())
      {
          var->setActive(shaderType, stream->readBool());
      }
  }
  
  void WriteInterfaceBlock(BinaryOutputStream *stream, const InterfaceBlock &block)
  {
      stream->writeString(block.name);
      stream->writeString(block.mappedName);
      stream->writeInt(block.isArray);
      stream->writeInt(block.arrayElement);
  
      WriteShaderVariableBuffer(stream, block);
  }
  
  void LoadInterfaceBlock(BinaryInputStream *stream, InterfaceBlock *block)
  {
      block->name         = stream->readString();
      block->mappedName   = stream->readString();
      block->isArray      = stream->readBool();
      block->arrayElement = stream->readInt<unsigned int>();
  
      LoadShaderVariableBuffer(stream, block);
  }
  }  // anonymous namespace
  
  // Saves the linking context for later use in resolveLink().
  struct Program::LinkingState
  {
      std::shared_ptr<ProgramExecutable> linkedExecutable;
      std::unique_ptr<ProgramLinkedResources> resources;
      egl::BlobCache::Key programHash;
      std::unique_ptr<rx::LinkEvent> linkEvent;
      bool linkingFromBinary;
  };
  
  const char *const g_fakepath = "C:\\fakepath";
  
  // InfoLog implementation.
  InfoLog::InfoLog() : mLazyStream(nullptr) {}
  
  InfoLog::~InfoLog() {}
  
  size_t InfoLog::getLength() const
  {
      if (!mLazyStream)
      {
          return 0;
      }
  
      const std::string &logString = mLazyStream->str();
      return logString.empty() ? 0 : logString.length() + 1;
  }
  
  void InfoLog::getLog(GLsizei bufSize, GLsizei *length, char *infoLog) const
  {
      size_t index = 0;
  
      if (bufSize > 0)
      {
          const std::string logString(str());
  
          if (!logString.empty())
          {
              index = std::min(static_cast<size_t>(bufSize) - 1, logString.length());
              memcpy(infoLog, logString.c_str(), index);
          }
  
          infoLog[index] = '\0';
      }
  
      if (length)
      {
          *length = static_cast<GLsizei>(index);
      }
  }
  
  // append a 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;
  }
  
  void WriteBlockMemberInfo(BinaryOutputStream *stream, const sh::BlockMemberInfo &var)
  {
      stream->writeInt(var.arrayStride);
      stream->writeInt(var.isRowMajorMatrix);
      stream->writeInt(var.matrixStride);
      stream->writeInt(var.offset);
      stream->writeInt(var.topLevelArrayStride);
  }
  
  void LoadBlockMemberInfo(BinaryInputStream *stream, sh::BlockMemberInfo *var)
  {
      var->arrayStride         = stream->readInt<int>();
      var->isRowMajorMatrix    = stream->readBool();
      var->matrixStride        = stream->readInt<int>();
      var->offset              = stream->readInt<int>();
      var->topLevelArrayStride = stream->readInt<int>();
  }
  
  void WriteShaderVar(BinaryOutputStream *stream, const sh::ShaderVariable &var)
  {
      stream->writeInt(var.type);
      stream->writeInt(var.precision);
      stream->writeString(var.name);
      stream->writeString(var.mappedName);
      stream->writeIntVector(var.arraySizes);
      stream->writeInt(var.staticUse);
      stream->writeInt(var.active);
      stream->writeInt(var.binding);
      stream->writeString(var.structName);
      stream->writeInt(var.hasParentArrayIndex() ? var.parentArrayIndex() : -1);
  
      stream->writeInt(var.imageUnitFormat);
      stream->writeInt(var.offset);
      stream->writeInt(var.readonly);
      stream->writeInt(var.writeonly);
  
      ASSERT(var.fields.empty());
  }
  
  void LoadShaderVar(BinaryInputStream *stream, sh::ShaderVariable *var)
  {
      var->type       = stream->readInt<GLenum>();
      var->precision  = stream->readInt<GLenum>();
      var->name       = stream->readString();
      var->mappedName = stream->readString();
      stream->readIntVector<unsigned int>(&var->arraySizes);
      var->staticUse  = stream->readBool();
      var->active     = stream->readBool();
      var->binding    = stream->readInt<int>();
      var->structName = stream->readString();
      var->setParentArrayIndex(stream->readInt<int>());
  
      var->imageUnitFormat = stream->readInt<GLenum>();
      var->offset          = stream->readInt<int>();
      var->readonly        = stream->readBool();
      var->writeonly       = stream->readBool();
  }
  
  // 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,
                                 SamplerFormat formatIn,
                                 size_t elementCount,
                                 bool unreferenced)
      : textureType(textureTypeIn),
        format(formatIn),
        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::getBindingByName(const std::string &name) const
  {
      auto iter = mBindings.find(name);
      return (iter != mBindings.end()) ? iter->second : -1;
  }
  
  int ProgramBindings::getBinding(const sh::ShaderVariable &variable) const
  {
      return getBindingByName(variable.name);
  }
  
  ProgramBindings::const_iterator ProgramBindings::begin() const
  {
      return mBindings.begin();
  }
  
  ProgramBindings::const_iterator ProgramBindings::end() const
  {
      return mBindings.end();
  }
  
  // ProgramAliasedBindings implementation.
  ProgramAliasedBindings::ProgramAliasedBindings() {}
  
  ProgramAliasedBindings::~ProgramAliasedBindings() {}
  
  void ProgramAliasedBindings::bindLocation(GLuint index, const std::string &name)
  {
      mBindings[name] = ProgramBinding(index);
  
      // EXT_blend_func_extended spec: "If it specifies the base name of an array,
      // it identifies the resources associated with the first element of the array."
      //
      // Normalize array bindings so that "name" and "name[0]" map to the same entry.
      // If this binding is of the form "name[0]", then mark the "name" binding as
      // aliased but do not update it yet in case "name" is not actually an array.
      size_t nameLengthWithoutArrayIndex;
      unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex);
      if (arrayIndex == 0)
      {
          std::string baseName = name.substr(0u, nameLengthWithoutArrayIndex);
          auto iter            = mBindings.find(baseName);
          if (iter != mBindings.end())
          {
              iter->second.aliased = true;
          }
      }
  }
  
  int ProgramAliasedBindings::getBindingByName(const std::string &name) const
  {
      auto iter = mBindings.find(name);
      return (iter != mBindings.end()) ? iter->second.location : -1;
  }
  
  int ProgramAliasedBindings::getBindingByLocation(GLuint location) const
  {
      for (const auto &iter : mBindings)
      {
          if (iter.second.location == location)
          {
              return iter.second.location;
          }
      }
      return -1;
  }
  
  int ProgramAliasedBindings::getBinding(const sh::ShaderVariable &variable) const
  {
      const std::string &name = variable.name;
  
      // Check with the normalized array name if applicable.
      if (variable.isArray())
      {
          size_t nameLengthWithoutArrayIndex;
          unsigned int arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndex);
          if (arrayIndex == 0)
          {
              std::string baseName = name.substr(0u, nameLengthWithoutArrayIndex);
              auto iter            = mBindings.find(baseName);
              // If "name" exists and is not aliased, that means it was modified more
              // recently than its "name[0]" form and should be used instead of that.
              if (iter != mBindings.end() && !iter->second.aliased)
              {
                  return iter->second.location;
              }
          }
          else if (arrayIndex == GL_INVALID_INDEX)
          {
              auto iter = mBindings.find(variable.name);
              // If "name" exists and is not aliased, that means it was modified more
              // recently than its "name[0]" form and should be used instead of that.
              if (iter != mBindings.end() && !iter->second.aliased)
              {
                  return iter->second.location;
              }
              // The base name was aliased, so use the name with the array notation.
              return getBindingByName(name + "[0]");
          }
      }
  
      return getBindingByName(name);
  }
  
  ProgramAliasedBindings::const_iterator ProgramAliasedBindings::begin() const
  {
      return mBindings.begin();
  }
  
  ProgramAliasedBindings::const_iterator ProgramAliasedBindings::end() const
  {
      return mBindings.end();
  }
  
  // ImageBinding implementation.
  ImageBinding::ImageBinding(size_t count) : boundImageUnits(count, 0), unreferenced(false) {}
  ImageBinding::ImageBinding(GLuint imageUnit, size_t count, bool unreferenced)
      : unreferenced(unreferenced)
  {
      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{},
        mAttachedShadersMarkedForDetach{},
        mAtomicCounterUniformRange(0, 0),
        mBinaryRetrieveableHint(false),
        mSeparable(false),
        mNumViews(-1),
        // [GL_EXT_geometry_shader] Table 20.22
        mGeometryShaderInputPrimitiveType(PrimitiveMode::Triangles),
        mGeometryShaderOutputPrimitiveType(PrimitiveMode::TriangleStrip),
        mGeometryShaderInvocations(1),
        mGeometryShaderMaxVertices(0),
        mDrawIDLocation(-1),
        mBaseVertexLocation(-1),
        mBaseInstanceLocation(-1),
        mCachedBaseVertex(0),
        mCachedBaseInstance(0),
        mExecutable(new ProgramExecutable())
  {
      mComputeShaderLocalSize.fill(1);
  }
  
  ProgramState::~ProgramState()
  {
      ASSERT(!hasAttachedShader());
  }
  
  const std::string &ProgramState::getLabel()
  {
      return mLabel;
  }
  
  Shader *ProgramState::getAttachedShader(ShaderType shaderType) const
  {
      ASSERT(shaderType != ShaderType::InvalidEnum);
      return mAttachedShaders[shaderType];
  }
  
  GLuint ProgramState::getUniformIndexFromName(const std::string &name) const
  {
      return GetResourceIndexFromName(mExecutable->mUniforms, name);
  }
  
  GLuint ProgramState::getBufferVariableIndexFromName(const std::string &name) const
  {
      return GetResourceIndexFromName(mBufferVariables, name);
  }
  
  GLuint ProgramState::getUniformIndexFromLocation(UniformLocation location) const
  {
      ASSERT(location.value >= 0 && static_cast<size_t>(location.value) < mUniformLocations.size());
      return mUniformLocations[location.value].index;
  }
  
  Optional<GLuint> ProgramState::getSamplerIndex(UniformLocation location) const
  {
      GLuint index = getUniformIndexFromLocation(location);
      if (!isSamplerUniformIndex(index))
      {
          return Optional<GLuint>::Invalid();
      }
  
      return getSamplerIndexFromUniformIndex(index);
  }
  
  bool ProgramState::isSamplerUniformIndex(GLuint index) const
  {
      return mExecutable->mSamplerUniformRange.contains(index);
  }
  
  GLuint ProgramState::getSamplerIndexFromUniformIndex(GLuint uniformIndex) const
  {
      ASSERT(isSamplerUniformIndex(uniformIndex));
      return uniformIndex - mExecutable->mSamplerUniformRange.low();
  }
  
  GLuint ProgramState::getUniformIndexFromSamplerIndex(GLuint samplerIndex) const
  {
      ASSERT(samplerIndex < mExecutable->mSamplerUniformRange.length());
      return samplerIndex + mExecutable->mSamplerUniformRange.low();
  }
  
  bool ProgramState::isImageUniformIndex(GLuint index) const
  {
      return mExecutable->mImageUniformRange.contains(index);
  }
  
  GLuint ProgramState::getImageIndexFromUniformIndex(GLuint uniformIndex) const
  {
      ASSERT(isImageUniformIndex(uniformIndex));
      return uniformIndex - mExecutable->mImageUniformRange.low();
  }
  
  GLuint ProgramState::getAttributeLocation(const std::string &name) const
  {
      for (const sh::ShaderVariable &attribute : mExecutable->mProgramInputs)
      {
          if (attribute.name == name)
          {
              return attribute.location;
          }
      }
  
      return static_cast<GLuint>(-1);
  }
  
  bool ProgramState::hasAttachedShader() const
  {
      for (const Shader *shader : mAttachedShaders)
      {
          if (shader)
          {
              return true;
          }
      }
      return false;
  }
  
  ShaderType ProgramState::getFirstAttachedShaderStageType() const
  {
      if (mExecutable->getLinkedShaderStages().none())
      {
          return ShaderType::InvalidEnum;
      }
  
      return *mExecutable->getLinkedShaderStages().begin();
  }
  
  ShaderType ProgramState::getLastAttachedShaderStageType() const
  {
      for (int i = gl::kAllGraphicsShaderTypes.size() - 1; i >= 0; --i)
      {
          const gl::ShaderType shaderType = gl::kAllGraphicsShaderTypes[i];
  
          if (mExecutable->hasLinkedShaderStage(shaderType))
          {
              return shaderType;
          }
      }
  
      if (mExecutable->hasLinkedShaderStage(ShaderType::Compute))
      {
          return ShaderType::Compute;
      }
  
      return ShaderType::InvalidEnum;
  }
  
  Program::Program(rx::GLImplFactory *factory, ShaderProgramManager *manager, ShaderProgramID handle)
      : mSerial(factory->generateSerial()),
        mProgram(factory->createProgram(mState)),
        mValidated(false),
        mLinked(false),
        mDeleteStatus(false),
        mRefCount(0),
        mResourceManager(manager),
        mHandle(handle)
  {
      ASSERT(mProgram);
  
      unlink();
  }
  
  Program::~Program()
  {
      ASSERT(!mProgram);
  }
  
  void Program::onDestroy(const Context *context)
  {
      resolveLink(context);
      for (ShaderType shaderType : AllShaderTypes())
      {
          if (mState.mAttachedShaders[shaderType])
          {
              mState.mAttachedShaders[shaderType]->release(context);
              mState.mAttachedShaders[shaderType]                = nullptr;
              mState.mAttachedShadersMarkedForDetach[shaderType] = false;
          }
      }
  
      mProgram->destroy(context);
  
      ASSERT(!mState.hasAttachedShader());
      SafeDelete(mProgram);
  
      delete this;
  }
  ShaderProgramID Program::id() const
  {
      ASSERT(!mLinkingState);
      return mHandle;
  }
  
  void Program::setLabel(const Context *context, const std::string &label)
  {
      ASSERT(!mLinkingState);
      mState.mLabel = label;
  }
  
  const std::string &Program::getLabel() const
  {
      ASSERT(!mLinkingState);
      return mState.mLabel;
  }
  
  void Program::attachShader(const Context *context, Shader *shader)
  {
      ASSERT(!mLinkingState);
      ShaderType shaderType = shader->getType();
      ASSERT(shaderType != ShaderType::InvalidEnum);
  
      // Since detachShader doesn't actually detach anymore, we need to do that work when attaching a
      // new shader to make sure we don't lose track of it and free the resources.
      if (mState.mAttachedShaders[shaderType])
      {
          mState.mAttachedShaders[shaderType]->release(context);
          mState.mAttachedShaders[shaderType]                = nullptr;
          mState.mAttachedShadersMarkedForDetach[shaderType] = false;
      }
  
      mState.mAttachedShaders[shaderType] = shader;
      mState.mAttachedShaders[shaderType]->addRef();
  }
  
  void Program::detachShader(const Context *context, Shader *shader)
  {
      ASSERT(!mLinkingState);
      ShaderType shaderType = shader->getType();
      ASSERT(shaderType != ShaderType::InvalidEnum);
  
      ASSERT(mState.mAttachedShaders[shaderType] == shader);
  
      if (isSeparable())
      {
          // Don't actually detach the shader since we still need it in case this
          // Program is part of a Program Pipeline Object. Instead, leave a mark
          // that indicates we intended to.
          mState.mAttachedShadersMarkedForDetach[shaderType] = true;
          return;
      }
  
      shader->release(context);
      mState.mAttachedShaders[shaderType]                = nullptr;
      mState.mAttachedShadersMarkedForDetach[shaderType] = false;
  }
  
  int Program::getAttachedShadersCount() const
  {
      ASSERT(!mLinkingState);
      int numAttachedShaders = 0;
      for (const Shader *shader : mState.mAttachedShaders)
      {
          if (shader)
          {
              ++numAttachedShaders;
          }
      }
  
      return numAttachedShaders;
  }
  
  const Shader *Program::getAttachedShader(ShaderType shaderType) const
  {
      ASSERT(!mLinkingState);
      return mState.getAttachedShader(shaderType);
  }
  
  void Program::bindAttributeLocation(GLuint index, const char *name)
  {
      ASSERT(!mLinkingState);
      mAttributeBindings.bindLocation(index, name);
  }
  
  void Program::bindUniformLocation(UniformLocation location, const char *name)
  {
      ASSERT(!mLinkingState);
      mState.mUniformLocationBindings.bindLocation(location.value, name);
  }
  
  void Program::bindFragmentOutputLocation(GLuint index, const char *name)
  {
      mFragmentOutputLocations.bindLocation(index, name);
  }
  
  void Program::bindFragmentOutputIndex(GLuint index, const char *name)
  {
      mFragmentOutputIndexes.bindLocation(index, name);
  }
  
  angle::Result Program::linkMergedVaryings(const Context *context,
                                            const ProgramExecutable &executable,
                                            const ProgramMergedVaryings &mergedVaryings)
  {
      ShaderType tfStage =
          mState.mAttachedShaders[ShaderType::Geometry] ? ShaderType::Geometry : ShaderType::Vertex;
      InfoLog &infoLog = getExecutable().getInfoLog();
  
      if (!linkValidateTransformFeedback(context->getClientVersion(), infoLog, mergedVaryings,
                                         tfStage, context->getCaps()))
      {
          return angle::Result::Stop;
      }
  
      if (!executable.mResources->varyingPacking.collectAndPackUserVaryings(
              infoLog, mergedVaryings, mState.getTransformFeedbackVaryingNames(), isSeparable()))
      {
          return angle::Result::Stop;
      }
  
      gatherTransformFeedbackVaryings(mergedVaryings, tfStage);
      mState.updateTransformFeedbackStrides();
  
      return angle::Result::Continue;
  }
  
  angle::Result Program::link(const Context *context)
  {
      angle::Result result = linkImpl(context);
  
      // Avoid having two ProgramExecutables if the link failed and the Program had successfully
      // linked previously.
      if (mLinkingState && mLinkingState->linkedExecutable)
      {
          mState.mExecutable = mLinkingState->linkedExecutable;
      }
  
      return result;
  }
  
  // The attached shaders are checked for linking errors by matching up their variables.
  // Uniform, input and output variables get collected.
  // The code gets compiled into binaries.
  angle::Result Program::linkImpl(const Context *context)
  {
      ASSERT(!mLinkingState);
      // Don't make any local variables pointing to anything within the ProgramExecutable, since
      // unlink() could make a new ProgramExecutable making any references/pointers invalid.
      const auto &data = context->getState();
      auto *platform   = ANGLEPlatformCurrent();
      double startTime = platform->currentTime(platform);
  
      // Unlink the program, but do not clear the validation-related caching yet, since we can still
      // use the previously linked program if linking the shaders fails.
      mLinked = false;
  
      mState.mExecutable->getInfoLog().reset();
  
      // Validate we have properly attached shaders before checking the cache.
      if (!linkValidateShaders(mState.mExecutable->getInfoLog()))
      {
          return angle::Result::Continue;
      }
  
      egl::BlobCache::Key programHash = {0};
      MemoryProgramCache *cache       = context->getMemoryProgramCache();
  
      // TODO: http://anglebug.com/4530: Enable program caching for separable programs
      if (cache && !isSeparable())
      {
          angle::Result cacheResult = cache->getProgram(context, this, &programHash);
          ANGLE_TRY(cacheResult);
  
          // Check explicitly for Continue, Incomplete means a cache miss
          if (cacheResult == angle::Result::Continue)
          {
              // Succeeded in loading the binaries in the front-end, back end may still be loading
              // asynchronously
              double delta = platform->currentTime(platform) - startTime;
              int us       = static_cast<int>(delta * 1000000.0);
              ANGLE_HISTOGRAM_COUNTS("GPU.ANGLE.ProgramCache.ProgramCacheHitTimeUS", us);
              return angle::Result::Continue;
          }
      }
  
      // Cache load failed, fall through to normal linking.
      unlink();
      InfoLog &infoLog = mState.mExecutable->getInfoLog();
  
      // Re-link shaders after the unlink call.
      bool result = linkValidateShaders(infoLog);
      ASSERT(result);
  
      if (mState.mAttachedShaders[ShaderType::Compute])
      {
          mState.mExecutable->mResources.reset(new ProgramLinkedResources(
              0, PackMode::ANGLE_RELAXED, &mState.mExecutable->mUniformBlocks,
              &mState.mExecutable->mUniforms, &mState.mExecutable->mShaderStorageBlocks,
              &mState.mBufferVariables, &mState.mExecutable->mAtomicCounterBuffers));
  
          GLuint combinedImageUniforms = 0u;
          if (!linkUniforms(context->getCaps(), context->getClientVersion(), infoLog,
                            mState.mUniformLocationBindings, &combinedImageUniforms,
                            &mState.mExecutable->getResources().unusedUniforms))
          {
              return angle::Result::Continue;
          }
  
          GLuint combinedShaderStorageBlocks = 0u;
          if (!linkInterfaceBlocks(context->getCaps(), context->getClientVersion(),
                                   context->getExtensions().webglCompatibility, infoLog,
                                   &combinedShaderStorageBlocks))
          {
              return angle::Result::Continue;
          }
  
          // [OpenGL ES 3.1] Chapter 8.22 Page 203:
          // A link error will be generated if the sum of the number of active image uniforms used in
          // all shaders, the number of active shader storage blocks, and the number of active
          // fragment shader outputs exceeds the implementation-dependent value of
          // MAX_COMBINED_SHADER_OUTPUT_RESOURCES.
          if (combinedImageUniforms + combinedShaderStorageBlocks >
              static_cast<GLuint>(context->getCaps().maxCombinedShaderOutputResources))
          {
              infoLog
                  << "The sum of the number of active image uniforms, active shader storage blocks "
                     "and active fragment shader outputs exceeds "
                     "MAX_COMBINED_SHADER_OUTPUT_RESOURCES ("
                  << context->getCaps().maxCombinedShaderOutputResources << ")";
              return angle::Result::Continue;
          }
  
          InitUniformBlockLinker(mState, &mState.mExecutable->getResources().uniformBlockLinker);
          InitShaderStorageBlockLinker(mState,
                                       &mState.mExecutable->getResources().shaderStorageBlockLinker);
      }
      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;
          }
  
          mState.mExecutable->mResources.reset(new ProgramLinkedResources(
              static_cast<GLuint>(data.getCaps().maxVaryingVectors), packMode,
              &mState.mExecutable->mUniformBlocks, &mState.mExecutable->mUniforms,
              &mState.mExecutable->mShaderStorageBlocks, &mState.mBufferVariables,
              &mState.mExecutable->mAtomicCounterBuffers));
  
          if (!linkAttributes(context, infoLog))
          {
              return angle::Result::Continue;
          }
  
          if (!linkVaryings(infoLog))
          {
              return angle::Result::Continue;
          }
  
          GLuint combinedImageUniforms = 0u;
          if (!linkUniforms(context->getCaps(), context->getClientVersion(), infoLog,
                            mState.mUniformLocationBindings, &combinedImageUniforms,
                            &mState.mExecutable->getResources().unusedUniforms))
          {
              return angle::Result::Continue;
          }
  
          GLuint combinedShaderStorageBlocks = 0u;
          if (!linkInterfaceBlocks(context->getCaps(), context->getClientVersion(),
                                   context->getExtensions().webglCompatibility, infoLog,
                                   &combinedShaderStorageBlocks))
          {
              return angle::Result::Continue;
          }
  
          gl::ShaderMap<const gl::ProgramState *> programStates;
          fillProgramStateMap(&programStates);
          if (!mState.mExecutable->linkValidateGlobalNames(infoLog, programStates))
          {
              return angle::Result::Continue;
          }
  
          if (!linkOutputVariables(context->getCaps(), context->getExtensions(),
                                   context->getClientVersion(), combinedImageUniforms,
                                   combinedShaderStorageBlocks))
          {
              return angle::Result::Continue;
          }
  
          gl::Shader *vertexShader = mState.mAttachedShaders[ShaderType::Vertex];
          if (vertexShader)
          {
              mState.mNumViews = vertexShader->getNumViews();
          }
  
          gl::Shader *fragmentShader = mState.mAttachedShaders[ShaderType::Fragment];
          if (fragmentShader)
          {
              mState.mEarlyFramentTestsOptimization =
                  fragmentShader->hasEarlyFragmentTestsOptimization();
          }
  
          InitUniformBlockLinker(mState, &mState.mExecutable->getResources().uniformBlockLinker);
          InitShaderStorageBlockLinker(mState,
                                       &mState.mExecutable->getResources().shaderStorageBlockLinker);
  
          ProgramPipeline *programPipeline = context->getState().getProgramPipeline();
          if (programPipeline && programPipeline->usesShaderProgram(id()))
          {
              const ProgramMergedVaryings &mergedVaryings =
                  context->getState().getProgramPipeline()->getMergedVaryings();
              ANGLE_TRY(linkMergedVaryings(context, *mState.mExecutable, mergedVaryings));
          }
          else
          {
              const ProgramMergedVaryings &mergedVaryings = getMergedVaryings();
              ANGLE_TRY(linkMergedVaryings(context, *mState.mExecutable, mergedVaryings));
          }
      }
  
      updateLinkedShaderStages();
  
      mLinkingState.reset(new LinkingState());
      mLinkingState->linkingFromBinary = false;
      mLinkingState->programHash       = programHash;
      mLinkingState->linkEvent = mProgram->link(context, mState.mExecutable->getResources(), infoLog);
  
      // Must be after mProgram->link() to avoid misleading the linker about output variables.
      mState.updateProgramInterfaceInputs();
      mState.updateProgramInterfaceOutputs();
  
      // Linking has succeeded, so we need to save some information that may get overwritten by a
      // later linkProgram() that could fail.
      if (mState.mSeparable)
      {
          mState.mExecutable->saveLinkedStateInfo(mState);
          mLinkingState->linkedExecutable = mState.mExecutable;
      }
  
      return angle::Result::Continue;
  }
  
  bool Program::isLinking() const
  {
      return (mLinkingState.get() && mLinkingState->linkEvent &&
              mLinkingState->linkEvent->isLinking());
  }
  
  void Program::resolveLinkImpl(const Context *context)
  {
      ASSERT(mLinkingState.get());
  
      angle::Result result = mLinkingState->linkEvent->wait(context);
  
      mLinked                                    = result == angle::Result::Continue;
      std::unique_ptr<LinkingState> linkingState = std::move(mLinkingState);
      if (!mLinked)
      {
          return;
      }
  
      if (linkingState->linkingFromBinary)
      {
          // All internal Program state is already loaded from the binary.
          return;
      }
  
      initInterfaceBlockBindings();
  
      // According to GLES 3.0/3.1 spec for LinkProgram and UseProgram,
      // Only successfully linked program can replace the executables.
      ASSERT(mLinked);
  
      // Mark implementation-specific unreferenced uniforms as ignored.
      mProgram->markUnusedUniformLocations(&mState.mUniformLocations,
                                           &mState.mExecutable->mSamplerBindings,
                                           &mState.mExecutable->mImageBindings);
  
      // Must be called after markUnusedUniformLocations.
      postResolveLink(context);
  
      // Save to the program cache.
      MemoryProgramCache *cache = context->getMemoryProgramCache();
      // TODO: http://anglebug.com/4530: Enable program caching for separable programs
      if (cache && !isSeparable() &&
          (mState.mExecutable->mLinkedTransformFeedbackVaryings.empty() ||
           !context->getFrontendFeatures().disableProgramCachingForTransformFeedback.enabled))
      {
          if (cache->putProgram(linkingState->programHash, context, this) == angle::Result::Stop)
          {
              // Don't fail linking if putting the program binary into the cache fails, the program is
              // still usable.
              WARN() << "Failed to save linked program to memory program cache.";
          }
      }
  }
  
  void Program::updateLinkedShaderStages()
  {
      mState.mExecutable->resetLinkedShaderStages();
  
      for (const Shader *shader : mState.mAttachedShaders)
      {
          if (shader)
          {
              mState.mExecutable->setLinkedShaderStages(shader->getType());
          }
      }
  
      if (mState.mExecutable->hasLinkedShaderStage(ShaderType::Compute))
      {
          mState.mExecutable->setIsCompute(true);
      }
      else
      {
          mState.mExecutable->setIsCompute(false);
      }
  }
  
  void ProgramState::updateTransformFeedbackStrides()
  {
      if (mExecutable->mTransformFeedbackBufferMode == GL_INTERLEAVED_ATTRIBS)
      {
          mExecutable->mTransformFeedbackStrides.resize(1);
          size_t totalSize = 0;
          for (const TransformFeedbackVarying &varying :
               mExecutable->mLinkedTransformFeedbackVaryings)
          {
              totalSize += varying.size() * VariableExternalSize(varying.type);
          }
          mExecutable->mTransformFeedbackStrides[0] = static_cast<GLsizei>(totalSize);
      }
      else
      {
          mExecutable->mTransformFeedbackStrides.resize(
              mExecutable->mLinkedTransformFeedbackVaryings.size());
          for (size_t i = 0; i < mExecutable->mLinkedTransformFeedbackVaryings.size(); i++)
          {
              TransformFeedbackVarying &varying = mExecutable->mLinkedTransformFeedbackVaryings[i];
              mExecutable->mTransformFeedbackStrides[i] =
                  static_cast<GLsizei>(varying.size() * VariableExternalSize(varying.type));
          }
      }
  }
  
  void ProgramState::updateActiveSamplers()
  {
      mExecutable->mActiveSamplerRefCounts.fill(0);
      mExecutable->updateActiveSamplers(*this);
  }
  
  void ProgramState::updateProgramInterfaceInputs()
  {
      const ShaderType firstAttachedShaderType = getFirstAttachedShaderStageType();
  
      if (firstAttachedShaderType == ShaderType::Vertex)
      {
          // Vertex attributes are already what we need, so nothing to do
          return;
      }
  
      Shader *shader = getAttachedShader(firstAttachedShaderType);
      ASSERT(shader);
  
      // Copy over each input varying, since the Shader could go away
      if (shader->getType() == ShaderType::Compute)
      {
          for (const sh::ShaderVariable &attribute : shader->getAllAttributes())
          {
              // Compute Shaders have the following built-in input variables.
              //
              // in uvec3 gl_NumWorkGroups;
              // in uvec3 gl_WorkGroupID;
              // in uvec3 gl_LocalInvocationID;
              // in uvec3 gl_GlobalInvocationID;
              // in uint  gl_LocalInvocationIndex;
              // They are all vecs or uints, so no special handling is required.
              mExecutable->mProgramInputs.emplace_back(attribute);
          }
      }
      else if (shader->getType() == ShaderType::Fragment)
      {
          for (const sh::ShaderVariable &varying : shader->getInputVaryings())
          {
              if (varying.isStruct())
              {
                  for (const sh::ShaderVariable &field : varying.fields)
                  {
                      sh::ShaderVariable fieldVarying = sh::ShaderVariable(field);
                      fieldVarying.location           = varying.location;
                      fieldVarying.name               = varying.name + "." + field.name;
                      mExecutable->mProgramInputs.emplace_back(fieldVarying);
                  }
              }
              else
              {
                  mExecutable->mProgramInputs.emplace_back(varying);
              }
          }
      }
  }
  
  void ProgramState::updateProgramInterfaceOutputs()
  {
      const ShaderType lastAttachedShaderType = getLastAttachedShaderStageType();
  
      if (lastAttachedShaderType == ShaderType::Fragment)
      {
          // Fragment outputs are already what we need, so nothing to do
          return;
      }
      if (lastAttachedShaderType == ShaderType::Compute)
      {
          // If the program only contains a Compute Shader, then there are no user-defined outputs.
          return;
      }
  
      Shader *shader = getAttachedShader(lastAttachedShaderType);
      ASSERT(shader);
  
      // Copy over each output varying, since the Shader could go away
      for (const sh::ShaderVariable &varying : shader->getOutputVaryings())
      {
          if (varying.isStruct())
          {
              for (const sh::ShaderVariable &field : varying.fields)
              {
                  sh::ShaderVariable fieldVarying = sh::ShaderVariable(field);
                  fieldVarying.location           = varying.location;
                  fieldVarying.name               = varying.name + "." + field.name;
                  mExecutable->mOutputVariables.emplace_back(fieldVarying);
              }
          }
          else
          {
              mExecutable->mOutputVariables.emplace_back(varying);
          }
      }
  }
  
  // Returns the program object to an unlinked state, before re-linking, or at destruction
  void Program::unlink()
  {
      if (mLinkingState && mLinkingState->linkedExecutable)
      {
          // The new ProgramExecutable that we'll attempt to link with needs to start from a copy of
          // the last successfully linked ProgramExecutable, so we don't lose any state information.
          mState.mExecutable.reset(new ProgramExecutable(*mLinkingState->linkedExecutable));
      }
      mState.mExecutable->reset();
  
      mState.mUniformLocations.clear();
      mState.mBufferVariables.clear();
      mState.mActiveUniformBlockBindings.reset();
      mState.mSecondaryOutputLocations.clear();
      mState.mOutputVariableTypes.clear();
      mState.mDrawBufferTypeMask.reset();
      mState.mActiveOutputVariables.reset();
      mState.mComputeShaderLocalSize.fill(1);
      mState.mNumViews                          = -1;
      mState.mGeometryShaderInputPrimitiveType  = PrimitiveMode::Triangles;
      mState.mGeometryShaderOutputPrimitiveType = PrimitiveMode::TriangleStrip;
      mState.mGeometryShaderInvocations         = 1;
      mState.mGeometryShaderMaxVertices         = 0;
      mState.mDrawIDLocation                    = -1;
      mState.mBaseVertexLocation                = -1;
      mState.mBaseInstanceLocation              = -1;
      mState.mCachedBaseVertex                  = 0;
      mState.mCachedBaseInstance                = 0;
      mState.mEarlyFramentTestsOptimization     = false;
  
      mValidated = false;
  
      mLinked = false;
  }
  
  angle::Result Program::loadBinary(const Context *context,
                                    GLenum binaryFormat,
                                    const void *binary,
                                    GLsizei length)
  {
      ASSERT(!mLinkingState);
      unlink();
      InfoLog &infoLog = mState.mExecutable->getInfoLog();
  
  #if ANGLE_PROGRAM_BINARY_LOAD != ANGLE_ENABLED
      return angle::Result::Continue;
  #else
      ASSERT(binaryFormat == GL_PROGRAM_BINARY_ANGLE);
      if (binaryFormat != GL_PROGRAM_BINARY_ANGLE)
      {
          infoLog << "Invalid program binary format.";
          return angle::Result::Continue;
      }
  
      BinaryInputStream stream(binary, length);
      ANGLE_TRY(deserialize(context, stream, infoLog));
  
      // Currently we require the full shader text to compute the program hash.
      // We could also store the binary in the internal program cache.
  
      for (size_t uniformBlockIndex = 0;
           uniformBlockIndex < mState.mExecutable->getActiveUniformBlockCount(); ++uniformBlockIndex)
      {
          mDirtyBits.set(uniformBlockIndex);
      }
  
      // The rx::LinkEvent returned from ProgramImpl::load is a base class with multiple
      // implementations. In some implementations, a background thread is used to compile the
      // shaders. Any calls to the LinkEvent object, therefore, are racy and may interfere with
      // the operation.
  
      // We do not want to call LinkEvent::wait because that will cause the background thread
      // to finish its task before returning, thus defeating the purpose of background compilation.
      // We need to defer waiting on background compilation until the very last minute when we
      // absolutely need the results, such as when the developer binds the program or queries
      // for the completion status.
  
      // If load returns nullptr, we know for sure that the binary is not compatible with the backend.
      // The loaded binary could have been read from the on-disk shader cache and be corrupted or
      // serialized with different revision and subsystem id than the currently loaded backend.
      // Returning 'Incomplete' to the caller results in link happening using the original shader
      // sources.
      angle::Result result;
      std::unique_ptr<LinkingState> linkingState;
      std::unique_ptr<rx::LinkEvent> linkEvent = mProgram->load(context, &stream, infoLog);
      if (linkEvent)
      {
          linkingState                    = std::make_unique<LinkingState>();
          linkingState->linkingFromBinary = true;
          linkingState->linkEvent         = std::move(linkEvent);
          result                          = angle::Result::Continue;
      }
      else
      {
          result = angle::Result::Incomplete;
      }
      mLinkingState = std::move(linkingState);
  
      return result;
  #endif  // #if ANGLE_PROGRAM_BINARY_LOAD == ANGLE_ENABLED
  }
  
  angle::Result Program::saveBinary(Context *context,
                                    GLenum *binaryFormat,
                                    void *binary,
                                    GLsizei bufSize,
                                    GLsizei *length) const
  {
      ASSERT(!mLinkingState);
      if (binaryFormat)
      {
          *binaryFormat = GL_PROGRAM_BINARY_ANGLE;
      }
  
      angle::MemoryBuffer memoryBuf;
      ANGLE_TRY(serialize(context, &memoryBuf));
  
      GLsizei streamLength       = static_cast<GLsizei>(memoryBuf.size());
      const uint8_t *streamState = memoryBuf.data();
  
      if (streamLength > bufSize)
      {
          if (length)
          {
              *length = 0;
          }
  
          // TODO: This should be moved to the validation layer but computing the size of the binary
          // before saving it causes the save to happen twice.  It may be possible to write the binary
          // to a separate buffer, validate sizes and then copy it.
          ANGLE_CHECK(context, false, "Insufficient buffer size", GL_INVALID_OPERATION);
      }
  
      if (binary)
      {
          char *ptr = reinterpret_cast<char *>(binary);
  
          memcpy(ptr, streamState, streamLength);
          ptr += streamLength;
  
          ASSERT(ptr - streamLength == binary);
      }
  
      if (length)
      {
          *length = streamLength;
      }
  
      return angle::Result::Continue;
  }
  
  GLint Program::getBinaryLength(Context *context) const
  {
      ASSERT(!mLinkingState);
      if (!mLinked)
      {
          return 0;
      }
  
      GLint length;
      angle::Result result =
          saveBinary(context, nullptr, nullptr, std::numeric_limits<GLint>::max(), &length);
      if (result != angle::Result::Continue)
      {
          return 0;
      }
  
      return length;
  }
  
  void Program::setBinaryRetrievableHint(bool retrievable)
  {
      ASSERT(!mLinkingState);
      // TODO(jmadill) : replace with dirty bits
      mProgram->setBinaryRetrievableHint(retrievable);
      mState.mBinaryRetrieveableHint = retrievable;
  }
  
  bool Program::getBinaryRetrievableHint() const
  {
      ASSERT(!mLinkingState);
      return mState.mBinaryRetrieveableHint;
  }
  
  void Program::setSeparable(bool separable)
  {
      ASSERT(!mLinkingState);
      // TODO(yunchao) : replace with dirty bits
      if (mState.mSeparable != separable)
      {
          mProgram->setSeparable(separable);
          mState.mSeparable = separable;
      }
  }
  
  bool Program::isSeparable() const
  {
      ASSERT(!mLinkingState);
      return mState.mSeparable;
  }
  
  void Program::deleteSelf(const Context *context)
  {
      ASSERT(mRefCount == 0 && mDeleteStatus);
      mResourceManager->deleteProgram(context, mHandle);
  }
  
  unsigned int Program::getRefCount() const
  {
      return mRefCount;
  }
  
  void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, ShaderProgramID *shaders) const
  {
      ASSERT(!mLinkingState);
      int total = 0;
  
      for (const Shader *shader : mState.mAttachedShaders)
      {
          if (shader && (total < maxCount))
          {
              shaders[total] = shader->getHandle();
              ++total;
          }
      }
  
      if (count)
      {
          *count = total;
      }
  }
  
  GLuint Program::getAttributeLocation(const std::string &name) const
  {
      ASSERT(!mLinkingState);
      return mState.getAttributeLocation(name);
  }
  
  void Program::getActiveAttribute(GLuint index,
                                   GLsizei bufsize,
                                   GLsizei *length,
                                   GLint *size,
                                   GLenum *type,
                                   GLchar *name) const
  {
      ASSERT(!mLinkingState);
      if (!mLinked)
      {
          if (bufsize > 0)
          {
              name[0] = '\0';
          }
  
          if (length)
          {
              *length = 0;
          }
  
          *type = GL_NONE;
          *size = 1;
          return;
      }
  
      ASSERT(index < mState.mExecutable->getProgramInputs().size());
      const sh::ShaderVariable &attrib = mState.mExecutable->getProgramInputs()[index];
  
      if (bufsize > 0)
      {
          CopyStringToBuffer(name, attrib.name, bufsize, length);
      }
  
      // Always a single 'type' instance
      *size = 1;
      *type = attrib.type;
  }
  
  GLint Program::getActiveAttributeCount() const
  {
      ASSERT(!mLinkingState);
      if (!mLinked)
      {
          return 0;
      }
  
      return static_cast<GLint>(mState.mExecutable->getProgramInputs().size());
  }
  
  GLint Program::getActiveAttributeMaxLength() const
  {
      ASSERT(!mLinkingState);
      if (!mLinked)
      {
          return 0;
      }
  
      size_t maxLength = 0;
  
      for (const sh::ShaderVariable &attrib : mState.mExecutable->getProgramInputs())
      {
          maxLength = std::max(attrib.name.length() + 1, maxLength);
      }
  
      return static_cast<GLint>(maxLength);
  }
  
  const std::vector<sh::ShaderVariable> &Program::getAttributes() const
  {
      ASSERT(!mLinkingState);
      return mState.mExecutable->getProgramInputs();
  }
  
  const sh::WorkGroupSize &Program::getComputeShaderLocalSize() const
  {
      ASSERT(!mLinkingState);
      return mState.mComputeShaderLocalSize;
  }
  
  PrimitiveMode Program::getGeometryShaderInputPrimitiveType() const
  {
      ASSERT(!mLinkingState);
      return mState.mGeometryShaderInputPrimitiveType;
  }
  PrimitiveMode Program::getGeometryShaderOutputPrimitiveType() const
  {
      ASSERT(!mLinkingState);
      return mState.mGeometryShaderOutputPrimitiveType;
  }
  GLint Program::getGeometryShaderInvocations() const
  {
      ASSERT(!mLinkingState);
      return mState.mGeometryShaderInvocations;
  }
  GLint Program::getGeometryShaderMaxVertices() const
  {
      ASSERT(!mLinkingState);
      return mState.mGeometryShaderMaxVertices;
  }
  
  const sh::ShaderVariable &Program::getInputResource(size_t index) const
  {
      ASSERT(!mLinkingState);
      ASSERT(index < mState.mExecutable->getProgramInputs().size());
      return mState.mExecutable->getProgramInputs()[index];
  }
  
  GLuint Program::getInputResourceIndex(const GLchar *name) const
  {
      ASSERT(!mLinkingState);
      const std::string nameString = StripLastArrayIndex(name);
  
      for (size_t index = 0; index < mState.mExecutable->getProgramInputs().size(); index++)
      {
          sh::ShaderVariable resource = getInputResource(index);
          if (resource.name == nameString)
          {
              return static_cast<GLuint>(index);
          }
      }
  
      return GL_INVALID_INDEX;
  }
  
  GLuint Program::getResourceMaxNameSize(const sh::ShaderVariable &resource, GLint max) const
  {
      if (resource.isArray())
      {
          return std::max(max, clampCast<GLint>((resource.name + "[0]").size()));
      }
      else
      {
          return std::max(max, clampCast<GLint>((resource.name).size()));
      }
  }
  
  GLuint Program::getInputResourceMaxNameSize() const
  {
      GLint max = 0;
  
      for (const sh::ShaderVariable &resource : mState.mExecutable->getProgramInputs())
      {
          max = getResourceMaxNameSize(resource, max);
      }
  
      return max;
  }
  
  GLuint Program::getOutputResourceMaxNameSize() const
  {
      GLint max = 0;
  
      for (const sh::ShaderVariable &resource : mState.mExecutable->getOutputVariables())
      {
          max = getResourceMaxNameSize(resource, max);
      }
  
      return max;
  }
  
  GLuint Program::getResourceLocation(const GLchar *name, const sh::ShaderVariable &variable) const
  {
      if (variable.isBuiltIn())
      {
          return GL_INVALID_INDEX;
      }
  
      GLint location = variable.location;
      if (variable.isArray())
      {
          size_t nameLengthWithoutArrayIndexOut;
          size_t arrayIndex = ParseArrayIndex(name, &nameLengthWithoutArrayIndexOut);
          // The 'name' string may not contain the array notation "[0]"
          if (arrayIndex != GL_INVALID_INDEX)
          {
              location += arrayIndex;
          }
      }
  
      return location;
  }
  
  GLuint Program::getInputResourceLocation(const GLchar *name) const
  {
      const GLuint index = getInputResourceIndex(name);
      if (index == GL_INVALID_INDEX)
      {
          return index;
      }
  
      const sh::ShaderVariable &variable = getInputResource(index);
  
      return getResourceLocation(name, variable);
  }
  
  GLuint Program::getOutputResourceLocation(const GLchar *name) const
  {
      const GLuint index = getOutputResourceIndex(name);
      if (index == GL_INVALID_INDEX)
      {
          return index;
      }
  
      const sh::ShaderVariable &variable = getOutputResource(index);
  
      return getResourceLocation(name, variable);
  }
  
  GLuint Program::getOutputResourceIndex(const GLchar *name) const
  {
      ASSERT(!mLinkingState);
      const std::string nameString = StripLastArrayIndex(name);
  
      for (size_t index = 0; index < mState.mExecutable->getOutputVariables().size(); index++)
      {
          sh::ShaderVariable resource = getOutputResource(index);
          if (resource.name == nameString)
          {
              return static_cast<GLuint>(index);
          }
      }
  
      return GL_INVALID_INDEX;
  }
  
  size_t Program::getOutputResourceCount() const
  {
      ASSERT(!mLinkingState);
      return (mLinked ? mState.mExecutable->getOutputVariables().size() : 0);
  }
  
  const std::vector<GLenum> &Program::getOutputVariableTypes() const
  {
      ASSERT(!mLinkingState);
      return mState.mOutputVariableTypes;
  }
  
  void Program::getResourceName(const std::string name,
                                GLsizei bufSize,
                                GLsizei *length,
                                GLchar *dest) const
  {
      if (length)
      {
          *length = 0;
      }
  
      if (!mLinked)
      {
          if (bufSize > 0)
          {
              dest[0] = '\0';
          }
          return;
      }
  
      if (bufSize > 0)
      {
          CopyStringToBuffer(dest, name, bufSize, length);
      }
  }
  
  void Program::getInputResourceName(GLuint index,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *name) const
  {
      ASSERT(!mLinkingState);
      getResourceName(getInputResourceName(index), bufSize, length, name);
  }
  
  void Program::getOutputResourceName(GLuint index,
                                      GLsizei bufSize,
                                      GLsizei *length,
                                      GLchar *name) const
  {
      ASSERT(!mLinkingState);
      getResourceName(getOutputResourceName(index), bufSize, length, name);
  }
  
  void Program::getUniformResourceName(GLuint index,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLchar *name) const
  {
      ASSERT(!mLinkingState);
      ASSERT(index < mState.mExecutable->getUniforms().size());
      getResourceName(mState.mExecutable->getUniforms()[index].name, bufSize, length, name);
  }
  
  void Program::getBufferVariableResourceName(GLuint index,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLchar *name) const
  {
      ASSERT(!mLinkingState);
      ASSERT(index < mState.mBufferVariables.size());
      getResourceName(mState.mBufferVariables[index].name, bufSize, length, name);
  }
  
  const std::string Program::getResourceName(const sh::ShaderVariable &resource) const
  {
      std::string resourceName = resource.name;
  
      if (resource.isArray())
      {
          resourceName += "[0]";
      }
  
      return resourceName;
  }
  
  const std::string Program::getInputResourceName(GLuint index) const
  {
      ASSERT(!mLinkingState);
      const sh::ShaderVariable &resource = getInputResource(index);
  
      return getResourceName(resource);
  }
  
  const std::string Program::getOutputResourceName(GLuint index) const
  {
      ASSERT(!mLinkingState);
      const sh::ShaderVariable &resource = getOutputResource(index);
  
      return getResourceName(resource);
  }
  
  const sh::ShaderVariable &Program::getOutputResource(size_t index) const
  {
      ASSERT(!mLinkingState);
      ASSERT(index < mState.mExecutable->getOutputVariables().size());
      return mState.mExecutable->getOutputVariables()[index];
  }
  
  const ProgramBindings &Program::getAttributeBindings() const
  {
      ASSERT(!mLinkingState);
      return mAttributeBindings;
  }
  const ProgramAliasedBindings &Program::getUniformLocationBindings() const
  {
      ASSERT(!mLinkingState);
      return mState.mUniformLocationBindings;
  }
  
  const gl::ProgramAliasedBindings &Program::getFragmentOutputLocations() const
  {
      ASSERT(!mLinkingState);
      return mFragmentOutputLocations;
  }
  
  const gl::ProgramAliasedBindings &Program::getFragmentOutputIndexes() const
  {
      ASSERT(!mLinkingState);
      return mFragmentOutputIndexes;
  }
  
  ComponentTypeMask Program::getDrawBufferTypeMask() const
  {
      ASSERT(!mLinkingState);
      return mState.mDrawBufferTypeMask;
  }
  
  const std::vector<GLsizei> &Program::getTransformFeedbackStrides() const
  {
      ASSERT(!mLinkingState);
      return mState.mExecutable->getTransformFeedbackStrides();
  }
  
  GLint Program::getFragDataLocation(const std::string &name) const
  {
      ASSERT(!mLinkingState);
      GLint primaryLocation = GetVariableLocation(mState.mExecutable->getOutputVariables(),
                                                  mState.mExecutable->getOutputLocations(), name);
      if (primaryLocation != -1)
      {
          return primaryLocation;
      }
      return GetVariableLocation(mState.mExecutable->getOutputVariables(),
                                 mState.mSecondaryOutputLocations, name);
  }
  
  GLint Program::getFragDataIndex(const std::string &name) const
  {
      ASSERT(!mLinkingState);
      if (GetVariableLocation(mState.mExecutable->getOutputVariables(),
                              mState.mExecutable->getOutputLocations(), name) != -1)
      {
          return 0;
      }
      if (GetVariableLocation(mState.mExecutable->getOutputVariables(),
                              mState.mSecondaryOutputLocations, name) != -1)
      {
          return 1;
      }
      return -1;
  }
  
  void Program::getActiveUniform(GLuint index,
                                 GLsizei bufsize,
                                 GLsizei *length,
                                 GLint *size,
                                 GLenum *type,
                                 GLchar *name) const
  {
      ASSERT(!mLinkingState);
      if (mLinked)
      {
          // index must be smaller than getActiveUniformCount()
          ASSERT(index < mState.mExecutable->getUniforms().size());
          const LinkedUniform &uniform = mState.mExecutable->getUniforms()[index];
  
          if (bufsize > 0)
          {
              std::string string = uniform.name;
              CopyStringToBuffer(name, string, bufsize, length);
          }
  
          *size = clampCast<GLint>(uniform.getBasicTypeElementCount());
          *type = uniform.type;
      }
      else
      {
          if (bufsize > 0)
          {
              name[0] = '\0';
          }
  
          if (length)
          {
              *length = 0;
          }
  
          *size = 0;
          *type = GL_NONE;
      }
  }
  
  GLint Program::getActiveUniformCount() const
  {
      ASSERT(!mLinkingState);
      if (mLinked)
      {
          return static_cast<GLint>(mState.mExecutable->getUniforms().size());
      }
      else
      {
          return 0;
      }
  }
  
  size_t Program::getActiveBufferVariableCount() const
  {
      ASSERT(!mLinkingState);
      return mLinked ? mState.mBufferVariables.size() : 0;
  }
  
  GLint Program::getActiveUniformMaxLength() const
  {
      ASSERT(!mLinkingState);
      size_t maxLength = 0;
  
      if (mLinked)
      {
          for (const LinkedUniform &uniform : mState.mExecutable->getUniforms())
          {
              if (!uniform.name.empty())
              {
                  size_t length = uniform.name.length() + 1u;
                  if (uniform.isArray())
                  {
                      length += 3;  // Counting in "[0]".
                  }
                  maxLength = std::max(length, maxLength);
              }
          }
      }
  
      return static_cast<GLint>(maxLength);
  }
  
  bool Program::isValidUniformLocation(UniformLocation location) const
  {
      ASSERT(!mLinkingState);
      ASSERT(angle::IsValueInRangeForNumericType<GLint>(mState.mUniformLocations.size()));
      return (location.value >= 0 &&
              static_cast<size_t>(location.value) < mState.mUniformLocations.size() &&
              mState.mUniformLocations[static_cast<size_t>(location.value)].used());
  }
  
  const LinkedUniform &Program::getUniformByLocation(UniformLocation location) const
  {
      ASSERT(!mLinkingState);
      ASSERT(location.value >= 0 &&
             static_cast<size_t>(location.value) < mState.mUniformLocations.size());
      return mState.mExecutable->getUniforms()[mState.getUniformIndexFromLocation(location)];
  }
  
  const VariableLocation &Program::getUniformLocation(UniformLocation location) const
  {
      ASSERT(!mLinkingState);
      ASSERT(location.value >= 0 &&
             static_cast<size_t>(location.value) < mState.mUniformLocations.size());
      return mState.mUniformLocations[location.value];
  }
  
  const BufferVariable &Program::getBufferVariableByIndex(GLuint index) const
  {
      ASSERT(!mLinkingState);
      ASSERT(index < static_cast<size_t>(mState.mBufferVariables.size()));
      return mState.mBufferVariables[index];
  }
  
  UniformLocation Program::getUniformLocation(const std::string &name) const
  {
      ASSERT(!mLinkingState);
      return {GetVariableLocation(mState.mExecutable->getUniforms(), mState.mUniformLocations, name)};
  }
  
  GLuint Program::getUniformIndex(const std::string &name) const
  {
      ASSERT(!mLinkingState);
      return mState.getUniformIndexFromName(name);
  }
  
  bool Program::shouldIgnoreUniform(UniformLocation location) const
  {
      if (location.value == -1)
      {
          return true;
      }
  
      if (mState.mUniformLocations[static_cast<size_t>(location.value)].ignored)
      {
          return true;
      }
  
      return false;
  }
  
  void Program::setUniform1fv(UniformLocation location, GLsizei count, const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
      mProgram->setUniform1fv(location.value, clampedCount, v);
  }
  
  void Program::setUniform2fv(UniformLocation location, GLsizei count, const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
      mProgram->setUniform2fv(location.value, clampedCount, v);
  }
  
  void Program::setUniform3fv(UniformLocation location, GLsizei count, const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
      mProgram->setUniform3fv(location.value, clampedCount, v);
  }
  
  void Program::setUniform4fv(UniformLocation location, GLsizei count, const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
      mProgram->setUniform4fv(location.value, clampedCount, v);
  }
  
  void Program::setUniform1iv(Context *context,
                              UniformLocation location,
                              GLsizei count,
                              const GLint *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
  
      mProgram->setUniform1iv(location.value, clampedCount, v);
  
      if (mState.isSamplerUniformIndex(locationInfo.index))
      {
          updateSamplerUniform(context, locationInfo, clampedCount, v);
      }
  }
  
  void Program::setUniform2iv(UniformLocation location, GLsizei count, const GLint *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
      mProgram->setUniform2iv(location.value, clampedCount, v);
  }
  
  void Program::setUniform3iv(UniformLocation location, GLsizei count, const GLint *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
      mProgram->setUniform3iv(location.value, clampedCount, v);
  }
  
  void Program::setUniform4iv(UniformLocation location, GLsizei count, const GLint *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
      mProgram->setUniform4iv(location.value, clampedCount, v);
  }
  
  void Program::setUniform1uiv(UniformLocation location, GLsizei count, const GLuint *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
      mProgram->setUniform1uiv(location.value, clampedCount, v);
  }
  
  void Program::setUniform2uiv(UniformLocation location, GLsizei count, const GLuint *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
      mProgram->setUniform2uiv(location.value, clampedCount, v);
  }
  
  void Program::setUniform3uiv(UniformLocation location, GLsizei count, const GLuint *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
      mProgram->setUniform3uiv(location.value, clampedCount, v);
  }
  
  void Program::setUniform4uiv(UniformLocation location, GLsizei count, const GLuint *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
      GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
      mProgram->setUniform4uiv(location.value, clampedCount, v);
  }
  
  void Program::setUniformMatrix2fv(UniformLocation location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      GLsizei clampedCount = clampMatrixUniformCount<2, 2>(location, count, transpose, v);
      mProgram->setUniformMatrix2fv(location.value, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix3fv(UniformLocation location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      GLsizei clampedCount = clampMatrixUniformCount<3, 3>(location, count, transpose, v);
      mProgram->setUniformMatrix3fv(location.value, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix4fv(UniformLocation location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      GLsizei clampedCount = clampMatrixUniformCount<4, 4>(location, count, transpose, v);
      mProgram->setUniformMatrix4fv(location.value, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix2x3fv(UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      GLsizei clampedCount = clampMatrixUniformCount<2, 3>(location, count, transpose, v);
      mProgram->setUniformMatrix2x3fv(location.value, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix2x4fv(UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      GLsizei clampedCount = clampMatrixUniformCount<2, 4>(location, count, transpose, v);
      mProgram->setUniformMatrix2x4fv(location.value, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix3x2fv(UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      GLsizei clampedCount = clampMatrixUniformCount<3, 2>(location, count, transpose, v);
      mProgram->setUniformMatrix3x2fv(location.value, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix3x4fv(UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      GLsizei clampedCount = clampMatrixUniformCount<3, 4>(location, count, transpose, v);
      mProgram->setUniformMatrix3x4fv(location.value, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix4x2fv(UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      GLsizei clampedCount = clampMatrixUniformCount<4, 2>(location, count, transpose, v);
      mProgram->setUniformMatrix4x2fv(location.value, clampedCount, transpose, v);
  }
  
  void Program::setUniformMatrix4x3fv(UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *v)
  {
      ASSERT(!mLinkingState);
      if (shouldIgnoreUniform(location))
      {
          return;
      }
  
      GLsizei clampedCount = clampMatrixUniformCount<4, 3>(location, count, transpose, v);
      mProgram->setUniformMatrix4x3fv(location.value, clampedCount, transpose, v);
  }
  
  GLuint Program::getSamplerUniformBinding(const VariableLocation &uniformLocation) const
  {
      ASSERT(!mLinkingState);
      GLuint samplerIndex = mState.getSamplerIndexFromUniformIndex(uniformLocation.index);
      const std::vector<GLuint> &boundTextureUnits =
          mState.mExecutable->mSamplerBindings[samplerIndex].boundTextureUnits;
      return boundTextureUnits[uniformLocation.arrayIndex];
  }
  
  GLuint Program::getImageUniformBinding(const VariableLocation &uniformLocation) const
  {
      ASSERT(!mLinkingState);
      GLuint imageIndex = mState.getImageIndexFromUniformIndex(uniformLocation.index);
      const std::vector<GLuint> &boundImageUnits =
          mState.mExecutable->mImageBindings[imageIndex].boundImageUnits;
      return boundImageUnits[uniformLocation.arrayIndex];
  }
  
  void Program::getUniformfv(const Context *context, UniformLocation location, GLfloat *v) const
  {
      ASSERT(!mLinkingState);
      const VariableLocation &uniformLocation = mState.getUniformLocations()[location.value];
      const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];
  
      if (uniform.isSampler())
      {
          *v = static_cast<GLfloat>(getSamplerUniformBinding(uniformLocation));
          return;
      }
      else if (uniform.isImage())
      {
          *v = static_cast<GLfloat>(getImageUniformBinding(uniformLocation));
          return;
      }
  
      const GLenum nativeType = gl::VariableComponentType(uniform.type);
      if (nativeType == GL_FLOAT)
      {
          mProgram->getUniformfv(context, location.value, v);
      }
      else
      {
          getUniformInternal(context, v, location, nativeType, VariableComponentCount(uniform.type));
      }
  }
  
  void Program::getUniformiv(const Context *context, UniformLocation location, GLint *v) const
  {
      ASSERT(!mLinkingState);
      const VariableLocation &uniformLocation = mState.getUniformLocations()[location.value];
      const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];
  
      if (uniform.isSampler())
      {
          *v = static_cast<GLint>(getSamplerUniformBinding(uniformLocation));
          return;
      }
      else if (uniform.isImage())
      {
          *v = static_cast<GLint>(getImageUniformBinding(uniformLocation));
          return;
      }
  
      const GLenum nativeType = gl::VariableComponentType(uniform.type);
      if (nativeType == GL_INT || nativeType == GL_BOOL)
      {
          mProgram->getUniformiv(context, location.value, v);
      }
      else
      {
          getUniformInternal(context, v, location, nativeType, VariableComponentCount(uniform.type));
      }
  }
  
  void Program::getUniformuiv(const Context *context, UniformLocation location, GLuint *v) const
  {
      ASSERT(!mLinkingState);
      const VariableLocation &uniformLocation = mState.getUniformLocations()[location.value];
      const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];
  
      if (uniform.isSampler())
      {
          *v = getSamplerUniformBinding(uniformLocation);
          return;
      }
      else if (uniform.isImage())
      {
          *v = getImageUniformBinding(uniformLocation);
          return;
      }
  
      const GLenum nativeType = VariableComponentType(uniform.type);
      if (nativeType == GL_UNSIGNED_INT)
      {
          mProgram->getUniformuiv(context, location.value, v);
      }
      else
      {
          getUniformInternal(context, v, location, nativeType, VariableComponentCount(uniform.type));
      }
  }
  
  void Program::flagForDeletion()
  {
      ASSERT(!mLinkingState);
      mDeleteStatus = true;
  }
  
  bool Program::isFlaggedForDeletion() const
  {
      ASSERT(!mLinkingState);
      return mDeleteStatus;
  }
  
  void Program::validate(const Caps &caps)
  {
      ASSERT(!mLinkingState);
      mState.mExecutable->resetInfoLog();
      InfoLog &infoLog = mState.mExecutable->getInfoLog();
  
      if (mLinked)
      {
          mValidated = ConvertToBool(mProgram->validate(caps, &infoLog));
      }
      else
      {
          infoLog << "Program has not been successfully linked.";
      }
  }
  
  bool Program::validateSamplersImpl(InfoLog *infoLog, const Caps &caps)
  {
      const ProgramExecutable *executable = mState.mExecutable.get();
      ASSERT(!mLinkingState);
  
      // 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 (size_t textureUnit : executable->mActiveSamplersMask)
      {
          if (executable->mActiveSamplerTypes[textureUnit] == TextureType::InvalidEnum)
          {
              if (infoLog)
              {
                  (*infoLog) << "Samplers of conflicting types refer to the same texture "
                                "image unit ("
                             << textureUnit << ").";
              }
  
              mCachedValidateSamplersResult = false;
              return false;
          }
      }
  
      mCachedValidateSamplersResult = true;
      return true;
  }
  
  bool Program::isValidated() const
  {
      ASSERT(!mLinkingState);
      return mValidated;
  }
  
  void Program::getActiveUniformBlockName(const GLuint blockIndex,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLchar *blockName) const
  {
      ASSERT(!mLinkingState);
      GetInterfaceBlockName(blockIndex, mState.mExecutable->getUniformBlocks(), bufSize, length,
                            blockName);
  }
  
  void Program::getActiveShaderStorageBlockName(const GLuint blockIndex,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLchar *blockName) const
  {
      ASSERT(!mLinkingState);
      GetInterfaceBlockName(blockIndex, mState.mExecutable->getShaderStorageBlocks(), bufSize, length,
                            blockName);
  }
  
  template <typename T>
  GLint Program::getActiveInterfaceBlockMaxNameLength(const std::vector<T> &resources) const
  {
      int maxLength = 0;
  
      if (mLinked)
      {
          for (const T &resource : resources)
          {
              if (!resource.name.empty())
              {
                  int length = static_cast<int>(resource.nameWithArrayIndex().length());
                  maxLength  = std::max(length + 1, maxLength);
              }
          }
      }
  
      return maxLength;
  }
  
  GLint Program::getActiveUniformBlockMaxNameLength() const
  {
      ASSERT(!mLinkingState);
      return getActiveInterfaceBlockMaxNameLength(mState.mExecutable->getUniformBlocks());
  }
  
  GLint Program::getActiveShaderStorageBlockMaxNameLength() const
  {
      ASSERT(!mLinkingState);
      return getActiveInterfaceBlockMaxNameLength(mState.mExecutable->getShaderStorageBlocks());
  }
  
  GLuint Program::getUniformBlockIndex(const std::string &name) const
  {
      ASSERT(!mLinkingState);
      return GetInterfaceBlockIndex(mState.mExecutable->getUniformBlocks(), name);
  }
  
  GLuint Program::getShaderStorageBlockIndex(const std::string &name) const
  {
      ASSERT(!mLinkingState);
      return GetInterfaceBlockIndex(mState.mExecutable->getShaderStorageBlocks(), name);
  }
  
  const InterfaceBlock &Program::getUniformBlockByIndex(GLuint index) const
  {
      ASSERT(!mLinkingState);
      ASSERT(index < static_cast<GLuint>(mState.mExecutable->getActiveUniformBlockCount()));
      return mState.mExecutable->getUniformBlocks()[index];
  }
  
  const InterfaceBlock &Program::getShaderStorageBlockByIndex(GLuint index) const
  {
      ASSERT(!mLinkingState);
      ASSERT(index < static_cast<GLuint>(mState.mExecutable->getActiveShaderStorageBlockCount()));
      return mState.mExecutable->getShaderStorageBlocks()[index];
  }
  
  void Program::bindUniformBlock(GLuint uniformBlockIndex, GLuint uniformBlockBinding)
  {
      ASSERT(!mLinkingState);
      mState.mExecutable->mUniformBlocks[uniformBlockIndex].binding = uniformBlockBinding;
      mState.mActiveUniformBlockBindings.set(uniformBlockIndex, uniformBlockBinding != 0);
      mDirtyBits.set(DIRTY_BIT_UNIFORM_BLOCK_BINDING_0 + uniformBlockIndex);
  }
  
  GLuint Program::getUniformBlockBinding(GLuint uniformBlockIndex) const
  {
      ASSERT(!mLinkingState);
      return mState.getUniformBlockBinding(uniformBlockIndex);
  }
  
  GLuint Program::getShaderStorageBlockBinding(GLuint shaderStorageBlockIndex) const
  {
      ASSERT(!mLinkingState);
      return mState.getShaderStorageBlockBinding(shaderStorageBlockIndex);
  }
  
  void Program::setTransformFeedbackVaryings(GLsizei count,
                                             const GLchar *const *varyings,
                                             GLenum bufferMode)
  {
      ASSERT(!mLinkingState);
      mState.mTransformFeedbackVaryingNames.resize(count);
      for (GLsizei i = 0; i < count; i++)
      {
          mState.mTransformFeedbackVaryingNames[i] = varyings[i];
      }
  
      mState.mExecutable->mTransformFeedbackBufferMode = bufferMode;
  }
  
  void Program::getTransformFeedbackVarying(GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLsizei *size,
                                            GLenum *type,
                                            GLchar *name) const
  {
      ASSERT(!mLinkingState);
      if (mLinked)
      {
          ASSERT(index < mState.mExecutable->mLinkedTransformFeedbackVaryings.size());
          const auto &var     = mState.mExecutable->mLinkedTransformFeedbackVaryings[index];
          std::string varName = var.nameWithArrayIndex();
          GLsizei lastNameIdx = std::min(bufSize - 1, static_cast<GLsizei>(varName.length()));
          if (length)
          {
              *length = lastNameIdx;
          }
          if (size)
          {
              *size = var.size();
          }
          if (type)
          {
              *type = var.type;
          }
          if (name)
          {
              memcpy(name, varName.c_str(), lastNameIdx);
              name[lastNameIdx] = '\0';
          }
      }
  }
  
  GLsizei Program::getTransformFeedbackVaryingCount() const
  {
      ASSERT(!mLinkingState);
      if (mLinked)
      {
          return static_cast<GLsizei>(mState.mExecutable->mLinkedTransformFeedbackVaryings.size());
      }
      else
      {
          return 0;
      }
  }
  
  GLsizei Program::getTransformFeedbackVaryingMaxLength() const
  {
      ASSERT(!mLinkingState);
      if (mLinked)
      {
          GLsizei maxSize = 0;
          for (const auto &var : mState.mExecutable->mLinkedTransformFeedbackVaryings)
          {
              maxSize =
                  std::max(maxSize, static_cast<GLsizei>(var.nameWithArrayIndex().length() + 1));
          }
  
          return maxSize;
      }
      else
      {
          return 0;
      }
  }
  
  GLenum Program::getTransformFeedbackBufferMode() const
  {
      ASSERT(!mLinkingState);
      return mState.mExecutable->getTransformFeedbackBufferMode();
  }
  
  bool Program::linkValidateShaders(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())
          {
              infoLog << "Attached compute shader is not compiled.";
              return false;
          }
          ASSERT(computeShader->getType() == ShaderType::Compute);
  
          mState.mComputeShaderLocalSize = computeShader->getWorkGroupSize();
  
          // 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 (isSeparable())
          {
              if (!fragmentShader && !vertexShader)
              {
                  infoLog << "No compiled shaders.";
                  return false;
              }
  
              ASSERT(!fragmentShader || fragmentShader->getType() == ShaderType::Fragment);
              if (fragmentShader && !fragmentShader->isCompiled())
              {
                  infoLog << "Fragment shader is not compiled.";
                  return false;
              }
  
              ASSERT(!vertexShader || vertexShader->getType() == ShaderType::Vertex);
              if (vertexShader && !vertexShader->isCompiled())
              {
                  infoLog << "Vertex shader is not compiled.";
                  return false;
              }
          }
          else
          {
              if (!fragmentShader || !fragmentShader->isCompiled())
              {
                  infoLog
                      << "No compiled fragment shader when at least one graphics shader is attached.";
                  return false;
              }
              ASSERT(fragmentShader->getType() == ShaderType::Fragment);
  
              if (!vertexShader || !vertexShader->isCompiled())
              {
                  infoLog
                      << "No compiled vertex shader when at least one graphics shader is attached.";
                  return false;
              }
              ASSERT(vertexShader->getType() == ShaderType::Vertex);
          }
  
          if (vertexShader && fragmentShader)
          {
              int vertexShaderVersion   = vertexShader->getShaderVersion();
              int fragmentShaderVersion = fragmentShader->getShaderVersion();
  
              if (fragmentShaderVersion != 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())
              {
                  infoLog << "The attached geometry shader isn't compiled.";
                  return false;
              }
  
              if (vertexShader &&
                  (geometryShader->getShaderVersion() != vertexShader->getShaderVersion()))
              {
                  infoLog << "Geometry shader version does not match vertex shader version.";
                  return false;
              }
              ASSERT(geometryShader->getType() == ShaderType::Geometry);
  
              Optional<PrimitiveMode> inputPrimitive =
                  geometryShader->getGeometryShaderInputPrimitiveType();
              if (!inputPrimitive.valid())
              {
                  infoLog << "Input primitive type is not specified in the geometry shader.";
                  return false;
              }
  
              Optional<PrimitiveMode> outputPrimitive =
                  geometryShader->getGeometryShaderOutputPrimitiveType();
              if (!outputPrimitive.valid())
              {
                  infoLog << "Output primitive type is not specified in the geometry shader.";
                  return false;
              }
  
              Optional<GLint> maxVertices = geometryShader->getGeometryShaderMaxVertices();
              if (!maxVertices.valid())
              {
                  infoLog << "'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();
          }
      }
  
      return true;
  }
  
  GLuint Program::getTransformFeedbackVaryingResourceIndex(const GLchar *name) const
  {
      ASSERT(!mLinkingState);
      for (GLuint tfIndex = 0; tfIndex < mState.mExecutable->mLinkedTransformFeedbackVaryings.size();
           ++tfIndex)
      {
          const auto &tf = mState.mExecutable->mLinkedTransformFeedbackVaryings[tfIndex];
          if (tf.nameWithArrayIndex() == name)
          {
              return tfIndex;
          }
      }
      return GL_INVALID_INDEX;
  }
  
  const TransformFeedbackVarying &Program::getTransformFeedbackVaryingResource(GLuint index) const
  {
      ASSERT(!mLinkingState);
      ASSERT(index < mState.mExecutable->mLinkedTransformFeedbackVaryings.size());
      return mState.mExecutable->mLinkedTransformFeedbackVaryings[index];
  }
  
  bool Program::hasDrawIDUniform() const
  {
      ASSERT(!mLinkingState);
      return mState.mDrawIDLocation >= 0;
  }
  
  void Program::setDrawIDUniform(GLint drawid)
  {
      ASSERT(!mLinkingState);
      ASSERT(mState.mDrawIDLocation >= 0);
      mProgram->setUniform1iv(mState.mDrawIDLocation, 1, &drawid);
  }
  
  bool Program::hasBaseVertexUniform() const
  {
      ASSERT(!mLinkingState);
      return mState.mBaseVertexLocation >= 0;
  }
  
  void Program::setBaseVertexUniform(GLint baseVertex)
  {
      ASSERT(!mLinkingState);
      ASSERT(mState.mBaseVertexLocation >= 0);
      if (baseVertex == mState.mCachedBaseVertex)
      {
          return;
      }
      mState.mCachedBaseVertex = baseVertex;
      mProgram->setUniform1iv(mState.mBaseVertexLocation, 1, &baseVertex);
  }
  
  bool Program::hasBaseInstanceUniform() const
  {
      ASSERT(!mLinkingState);
      return mState.mBaseInstanceLocation >= 0;
  }
  
  void Program::setBaseInstanceUniform(GLuint baseInstance)
  {
      ASSERT(!mLinkingState);
      ASSERT(mState.mBaseInstanceLocation >= 0);
      if (baseInstance == mState.mCachedBaseInstance)
      {
          return;
      }
      mState.mCachedBaseInstance = baseInstance;
      GLint baseInstanceInt      = baseInstance;
      mProgram->setUniform1iv(mState.mBaseInstanceLocation, 1, &baseInstanceInt);
  }
  
  bool Program::linkVaryings(InfoLog &infoLog) const
  {
      ShaderType previousShaderType = ShaderType::InvalidEnum;
      for (ShaderType shaderType : kAllGraphicsShaderTypes)
      {
          Shader *currentShader = mState.mAttachedShaders[shaderType];
          if (!currentShader)
          {
              continue;
          }
  
          if (previousShaderType != ShaderType::InvalidEnum)
          {
              Shader *previousShader = mState.mAttachedShaders[previousShaderType];
              const std::vector<sh::ShaderVariable> &outputVaryings =
                  previousShader->getOutputVaryings();
  
              if (!linkValidateShaderInterfaceMatching(
                      outputVaryings, currentShader->getInputVaryings(), previousShaderType,
                      currentShader->getType(), previousShader->getShaderVersion(),
                      currentShader->getShaderVersion(), isSeparable(), infoLog))
              {
                  return false;
              }
          }
          previousShaderType = currentShader->getType();
      }
  
      Shader *vertexShader   = mState.mAttachedShaders[ShaderType::Vertex];
      Shader *fragmentShader = mState.mAttachedShaders[ShaderType::Fragment];
      if (vertexShader && fragmentShader &&
          !linkValidateBuiltInVaryings(vertexShader->getOutputVaryings(),
                                       fragmentShader->getInputVaryings(),
                                       vertexShader->getShaderVersion(), infoLog))
      {
          return false;
      }
  
      return true;
  }
  
  void Program::getFilteredVaryings(const std::vector<sh::ShaderVariable> &varyings,
                                    std::vector<const sh::ShaderVariable *> *filteredVaryingsOut)
  {
      for (const sh::ShaderVariable &varying : varyings)
      {
          // Built-in varyings obey special rules
          if (varying.isBuiltIn())
          {
              continue;
          }
  
          filteredVaryingsOut->push_back(&varying);
      }
  }
  
  bool Program::doShaderVariablesMatch(int outputShaderVersion,
                                       ShaderType outputShaderType,
                                       ShaderType inputShaderType,
                                       const sh::ShaderVariable &input,
                                       const sh::ShaderVariable &output,
                                       bool validateGeometryShaderInputs,
                                       bool isSeparable,
                                       gl::InfoLog &infoLog)
  {
      bool namesMatch     = input.name == output.name;
      bool locationsMatch = (input.location != -1) && (input.location == output.location);
  
      // An output variable is considered to match an input variable in the subsequent
      // shader if:
      // - the two variables match in name, type, and qualification; or
      // - the two variables are declared with the same location qualifier and
      //   match in type and qualification.
  
      if (namesMatch || locationsMatch)
      {
          std::string mismatchedStructFieldName;
          LinkMismatchError linkError =
              LinkValidateVaryings(output, input, outputShaderVersion, validateGeometryShaderInputs,
                                   isSeparable, &mismatchedStructFieldName);
          if (linkError != LinkMismatchError::NO_MISMATCH)
          {
              LogLinkMismatch(infoLog, input.name, "varying", linkError, mismatchedStructFieldName,
                              outputShaderType, inputShaderType);
              return false;
          }
  
          return true;
      }
  
      return false;
  }
  
  // [OpenGL ES 3.1] Chapter 7.4.1 "Shader Interface Matching" Page 91
  // TODO(jiawei.shao@intel.com): add validation on input/output blocks matching
  bool Program::linkValidateShaderInterfaceMatching(
      const std::vector<sh::ShaderVariable> &outputVaryings,
      const std::vector<sh::ShaderVariable> &inputVaryings,
      ShaderType outputShaderType,
      ShaderType inputShaderType,
      int outputShaderVersion,
      int inputShaderVersion,
      bool isSeparable,
      gl::InfoLog &infoLog)
  {
      ASSERT(outputShaderVersion == inputShaderVersion);
  
      std::vector<const sh::ShaderVariable *> filteredInputVaryings;
      std::vector<const sh::ShaderVariable *> filteredOutputVaryings;
      bool validateGeometryShaderInputs = inputShaderType == ShaderType::Geometry;
  
      getFilteredVaryings(inputVaryings, &filteredInputVaryings);
      getFilteredVaryings(outputVaryings, &filteredOutputVaryings);
  
      // Separable programs require the number of inputs and outputs match
      if (isSeparable && filteredInputVaryings.size() < filteredOutputVaryings.size())
      {
          infoLog << GetShaderTypeString(inputShaderType)
                  << " does not consume all varyings generated by "
                  << GetShaderTypeString(outputShaderType);
          return false;
      }
      if (isSeparable && filteredInputVaryings.size() > filteredOutputVaryings.size())
      {
          infoLog << GetShaderTypeString(outputShaderType)
                  << " does not generate all varyings consumed by "
                  << GetShaderTypeString(inputShaderType);
          return false;
      }
  
      // All inputs must match all outputs
      for (const sh::ShaderVariable *input : filteredInputVaryings)
      {
          bool match = false;
          for (const sh::ShaderVariable *output : filteredOutputVaryings)
          {
              if (doShaderVariablesMatch(outputShaderVersion, outputShaderType, inputShaderType,
                                         *input, *output, validateGeometryShaderInputs, isSeparable,
                                         infoLog))
              {
                  match = 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 (!match && input->staticUse)
          {
              infoLog << GetShaderTypeString(inputShaderType) << " varying " << input->name
                      << " does not match any " << GetShaderTypeString(outputShaderType)
                      << " varying";
              return false;
          }
      }
  
      return true;
  }
  
  bool Program::linkUniforms(const Caps &caps,
                             const Version &version,
                             InfoLog &infoLog,
                             const ProgramAliasedBindings &uniformLocationBindings,
                             GLuint *combinedImageUniformsCount,
                             std::vector<UnusedUniform> *unusedUniforms)
  {
      UniformLinker linker(mState);
      if (!linker.link(caps, infoLog, uniformLocationBindings))
      {
          return false;
      }
  
      linker.getResults(&mState.mExecutable->mUniforms, unusedUniforms, &mState.mUniformLocations);
  
      linkSamplerAndImageBindings(combinedImageUniformsCount);
  
      if (!linkAtomicCounterBuffers())
      {
          return false;
      }
  
      if (version >= Version(3, 1))
      {
          GLint locationSize = static_cast<GLint>(mState.getUniformLocations().size());
  
          if (locationSize > caps.maxUniformLocations)
          {
              infoLog << "Exceeded maximum uniform location size";
              return false;
          }
      }
  
      return true;
  }
  
  void Program::linkSamplerAndImageBindings(GLuint *combinedImageUniforms)
  {
      ASSERT(combinedImageUniforms);
  
      // Iterate over mExecutable->mUniforms from the back, and find the range of atomic counters,
      // images and samplers in that order.
      auto highIter = mState.mExecutable->getUniforms().rbegin();
      auto lowIter  = highIter;
  
      unsigned int high = static_cast<unsigned int>(mState.mExecutable->getUniforms().size());
      unsigned int low  = high;
  
      // Note that uniform block uniforms are not yet appended to this list.
      ASSERT(mState.mExecutable->getUniforms().size() == 0 || highIter->isAtomicCounter() ||
             highIter->isImage() || highIter->isSampler() || highIter->isInDefaultBlock());
  
      for (; lowIter != mState.mExecutable->getUniforms().rend() && lowIter->isAtomicCounter();
           ++lowIter)
      {
          --low;
      }
  
      mState.mAtomicCounterUniformRange = RangeUI(low, high);
  
      highIter = lowIter;
      high     = low;
  
      for (; lowIter != mState.mExecutable->getUniforms().rend() && lowIter->isImage(); ++lowIter)
      {
          --low;
      }
  
      mState.mExecutable->mImageUniformRange = RangeUI(low, high);
      *combinedImageUniforms                 = 0u;
      // If uniform is a image type, insert it into the mImageBindings array.
      for (unsigned int imageIndex : mState.mExecutable->getImageUniformRange())
      {
          // 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.mExecutable->getUniforms()[imageIndex];
          if (imageUniform.binding == -1)
          {
              mState.mExecutable->mImageBindings.emplace_back(
                  ImageBinding(imageUniform.getBasicTypeElementCount()));
          }
          else
          {
              mState.mExecutable->mImageBindings.emplace_back(
                  ImageBinding(imageUniform.binding, imageUniform.getBasicTypeElementCount(), false));
          }
  
          GLuint arraySize = imageUniform.isArray() ? imageUniform.arraySizes[0] : 1u;
          *combinedImageUniforms += imageUniform.activeShaderCount() * arraySize;
      }
  
      highIter = lowIter;
      high     = low;
  
      for (; lowIter != mState.mExecutable->getUniforms().rend() && lowIter->isSampler(); ++lowIter)
      {
          --low;
      }
  
      mState.mExecutable->mSamplerUniformRange = RangeUI(low, high);
  
      // If uniform is a sampler type, insert it into the mSamplerBindings array.
      for (unsigned int samplerIndex : mState.mExecutable->getSamplerUniformRange())
      {
          const auto &samplerUniform = mState.mExecutable->getUniforms()[samplerIndex];
          TextureType textureType    = SamplerTypeToTextureType(samplerUniform.type);
          unsigned int elementCount  = samplerUniform.getBasicTypeElementCount();
          SamplerFormat format       = samplerUniform.typeInfo->samplerFormat;
          mState.mExecutable->mSamplerBindings.emplace_back(textureType, format, elementCount, false);
      }
  
      // Whatever is left constitutes the default uniforms.
      mState.mExecutable->mDefaultUniformRange = RangeUI(0, low);
  }
  
  bool Program::linkAtomicCounterBuffers()
  {
      for (unsigned int index : mState.mAtomicCounterUniformRange)
      {
          auto &uniform                      = mState.mExecutable->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.mExecutable->getActiveAtomicCounterBufferCount(); ++bufferIndex)
          {
              auto &buffer = mState.mExecutable->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.mExecutable->mAtomicCounterBuffers.push_back(atomicCounterBuffer);
              uniform.bufferIndex =
                  static_cast<int>(mState.mExecutable->getActiveAtomicCounterBufferCount() - 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 (except built-ins) from the bindings and program locations.
  bool Program::linkAttributes(const Context *context, InfoLog &infoLog)
  {
      const Caps &caps               = context->getCaps();
      const Limitations &limitations = context->getLimitations();
      bool webglCompatibility        = context->getExtensions().webglCompatibility;
      int shaderVersion              = -1;
      unsigned int usedLocations     = 0;
  
      Shader *vertexShader = mState.getAttachedShader(gl::ShaderType::Vertex);
  
      if (!vertexShader)
      {
          // No vertex shader, so no attributes, so nothing to do
          return true;
      }
  
      shaderVersion = vertexShader->getShaderVersion();
      if (shaderVersion >= 300)
      {
          // In GLSL ES 3.00.6, aliasing checks should be done with all declared attributes -
          // see GLSL ES 3.00.6 section 12.46. Inactive attributes will be pruned after
          // aliasing checks.
          mState.mExecutable->mProgramInputs = vertexShader->getAllAttributes();
      }
      else
      {
          // In GLSL ES 1.00.17 we only do aliasing checks for active attributes.
          mState.mExecutable->mProgramInputs = vertexShader->getActiveAttributes();
      }
  
      GLuint maxAttribs = static_cast<GLuint>(caps.maxVertexAttributes);
      std::vector<sh::ShaderVariable *> usedAttribMap(maxAttribs, nullptr);
  
      // Assign locations to attributes that have a binding location and check for attribute aliasing.
      for (sh::ShaderVariable &attribute : mState.mExecutable->mProgramInputs)
      {
          // GLSL ES 3.10 January 2016 section 4.3.4: Vertex shader inputs can't be arrays or
          // structures, so we don't need to worry about adjusting their names or generating entries
          // for each member/element (unlike uniforms for example).
          ASSERT(!attribute.isArray() && !attribute.isStruct());
  
          int bindingLocation = mAttributeBindings.getBinding(attribute);
          if (attribute.location == -1 && bindingLocation != -1)
          {
              attribute.location = bindingLocation;
          }
  
          if (attribute.location != -1)
          {
              // Location is set by glBindAttribLocation or by location layout qualifier
              const int regs = VariableRegisterCount(attribute.type);
  
              if (static_cast<GLuint>(regs + attribute.location) > maxAttribs)
              {
                  infoLog << "Attribute (" << attribute.name << ") at location " << attribute.location
                          << " is too big to fit";
  
                  return false;
              }
  
              for (int reg = 0; reg < regs; reg++)
              {
                  const int regLocation               = attribute.location + reg;
                  sh::ShaderVariable *linkedAttribute = usedAttribMap[regLocation];
  
                  // In GLSL ES 3.00.6 and in WebGL, attribute aliasing produces a link error.
                  // In non-WebGL GLSL ES 1.00.17, attribute aliasing is allowed with some
                  // restrictions - see GLSL ES 1.00.17 section 2.10.4, but ANGLE currently has a bug.
                  // In D3D 9 and 11, aliasing is not supported, so check a limitation.
                  if (linkedAttribute)
                  {
                      if (shaderVersion >= 300 || webglCompatibility ||
                          limitations.noVertexAttributeAliasing)
                      {
                          infoLog << "Attribute '" << attribute.name << "' aliases attribute '"
                                  << linkedAttribute->name << "' at location " << regLocation;
                          return false;
                      }
                  }
                  else
                  {
                      usedAttribMap[regLocation] = &attribute;
                  }
  
                  usedLocations |= 1 << regLocation;
              }
          }
      }
  
      // Assign locations to attributes that don't have a binding location.
      for (sh::ShaderVariable &attribute : mState.mExecutable->mProgramInputs)
      {
          // Not set by glBindAttribLocation or by location layout qualifier
          if (attribute.location == -1)
          {
              int regs           = VariableRegisterCount(attribute.type);
              int availableIndex = AllocateFirstFreeBits(&usedLocations, regs, maxAttribs);
  
              if (availableIndex == -1 || static_cast<GLuint>(availableIndex + regs) > maxAttribs)
              {
                  infoLog << "Too many attributes (" << attribute.name << ")";
                  return false;
              }
  
              attribute.location = availableIndex;
          }
      }
  
      ASSERT(mState.mExecutable->mAttributesTypeMask.none());
      ASSERT(mState.mExecutable->mAttributesMask.none());
  
      // Prune inactive attributes. This step is only needed on shaderVersion >= 300 since on earlier
      // shader versions we're only processing active attributes to begin with.
      if (shaderVersion >= 300)
      {
          for (auto attributeIter = mState.mExecutable->getProgramInputs().begin();
               attributeIter != mState.mExecutable->getProgramInputs().end();)
          {
              if (attributeIter->active)
              {
                  ++attributeIter;
              }
              else
              {
                  attributeIter = mState.mExecutable->mProgramInputs.erase(attributeIter);
              }
          }
      }
  
      for (const sh::ShaderVariable &attribute : mState.mExecutable->getProgramInputs())
      {
          ASSERT(attribute.active);
          ASSERT(attribute.location != -1);
          unsigned int regs = static_cast<unsigned int>(VariableRegisterCount(attribute.type));
  
          unsigned int location = static_cast<unsigned int>(attribute.location);
          for (unsigned int r = 0; r < regs; r++)
          {
              // Built-in active program inputs don't have a bound attribute.
              if (!attribute.isBuiltIn())
              {
                  mState.mExecutable->mActiveAttribLocationsMask.set(location);
                  mState.mExecutable->mMaxActiveAttribLocation =
                      std::max(mState.mExecutable->mMaxActiveAttribLocation, location + 1);
  
                  ComponentType componentType =
                      GLenumToComponentType(VariableComponentType(attribute.type));
  
                  SetComponentTypeMask(componentType, location,
                                       &mState.mExecutable->mAttributesTypeMask);
                  mState.mExecutable->mAttributesMask.set(location);
  
                  location++;
              }
          }
      }
  
      return true;
  }
  
  bool Program::linkInterfaceBlocks(const Caps &caps,
                                    const Version &version,
                                    bool webglCompatibility,
                                    InfoLog &infoLog,
                                    GLuint *combinedShaderStorageBlocksCount)
  {
      ASSERT(combinedShaderStorageBlocksCount);
  
      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();
          if (!uniformBlocks.empty())
          {
              if (!ValidateInterfaceBlocksCount(
                      static_cast<GLuint>(caps.maxShaderUniformBlocks[shaderType]), uniformBlocks,
                      shaderType, sh::BlockType::BLOCK_UNIFORM, &combinedUniformBlocksCount, infoLog))
              {
                  return false;
              }
  
              allShaderUniformBlocks[shaderType] = &uniformBlocks;
              ++numShadersHasUniformBlocks;
          }
      }
  
      if (combinedUniformBlocksCount > static_cast<GLuint>(caps.maxCombinedUniformBlocks))
      {
          infoLog << "The sum of the number of active uniform blocks exceeds "
                     "MAX_COMBINED_UNIFORM_BLOCKS ("
                  << caps.maxCombinedUniformBlocks << ").";
          return false;
      }
  
      if (!ValidateInterfaceBlocksMatch(numShadersHasUniformBlocks, allShaderUniformBlocks, infoLog,
                                        webglCompatibility))
      {
          return false;
      }
  
      if (version >= 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();
              if (!shaderStorageBlocks.empty())
              {
                  if (!ValidateInterfaceBlocksCount(
                          static_cast<GLuint>(caps.maxShaderStorageBlocks[shaderType]),
                          shaderStorageBlocks, shaderType, sh::BlockType::BLOCK_BUFFER,
                          combinedShaderStorageBlocksCount, infoLog))
                  {
                      return false;
                  }
  
                  allShaderStorageBlocks[shaderType] = &shaderStorageBlocks;
                  ++numShadersHasShaderStorageBlocks;
              }
          }
  
          if (*combinedShaderStorageBlocksCount >
              static_cast<GLuint>(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.imageUnitFormat != variable2.imageUnitFormat)
      {
          return LinkMismatchError::FORMAT_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::ShaderVariable &outputVarying,
                                                  const sh::ShaderVariable &inputVarying,
                                                  int shaderVersion,
                                                  bool validateGeometryShaderInputVarying,
                                                  bool isSeparable,
                                                  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.
      bool validatePrecision = isSeparable && (shaderVersion > 100);
      LinkMismatchError linkError =
          LinkValidateVariablesBase(outputVarying, inputVarying, validatePrecision,
                                    !validateGeometryShaderInputVarying, mismatchedStructFieldName);
      if (linkError != LinkMismatchError::NO_MISMATCH)
      {
          return linkError;
      }
  
      // Explicit locations must match if the names match.
      if ((outputVarying.name == inputVarying.name) &&
          (outputVarying.location != inputVarying.location))
      {
          return LinkMismatchError::LOCATION_MISMATCH;
      }
  
      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 std::vector<sh::ShaderVariable> &vertexVaryings,
                                            const std::vector<sh::ShaderVariable> &fragmentVaryings,
                                            int vertexShaderVersion,
                                            InfoLog &infoLog)
  {
      if (vertexShaderVersion != 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::ShaderVariable &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::ShaderVariable &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 Version &version,
                                              InfoLog &infoLog,
                                              const ProgramMergedVaryings &varyings,
                                              ShaderType stage,
                                              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 (version < Version(3, 1) && tfVaryingName.find('[') != std::string::npos)
          {
              infoLog << "Capture of array elements is undefined and not supported.";
              return false;
          }
          if (version >= 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 = FindOutputVaryingOrField(varyings, stage, 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 (version < 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.mExecutable->getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS &&
              componentCount > static_cast<GLuint>(caps.maxTransformFeedbackSeparateComponents))
          {
              infoLog << "Transform feedback varying " << tfVaryingName << " components ("
                      << componentCount << ") exceed the maximum separate components ("
                      << caps.maxTransformFeedbackSeparateComponents << ").";
              return false;
          }
  
          totalComponents += componentCount;
          if (mState.mExecutable->getTransformFeedbackBufferMode() == GL_INTERLEAVED_ATTRIBS &&
              totalComponents > static_cast<GLuint>(caps.maxTransformFeedbackInterleavedComponents))
          {
              infoLog << "Transform feedback varying total components (" << totalComponents
                      << ") exceed the maximum interleaved components ("
                      << caps.maxTransformFeedbackInterleavedComponents << ").";
              return false;
          }
      }
      return true;
  }
  
  void Program::gatherTransformFeedbackVaryings(const ProgramMergedVaryings &varyings,
                                                ShaderType stage)
  {
      // Gather the linked varyings that are used for transform feedback, they should all exist.
      mState.mExecutable->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 ProgramVaryingRef &ref : varyings)
          {
              if (ref.frontShaderStage != stage)
              {
                  continue;
              }
  
              const sh::ShaderVariable *varying = ref.get(stage);
              if (baseName == varying->name)
              {
                  mState.mExecutable->mLinkedTransformFeedbackVaryings.emplace_back(
                      *varying, static_cast<GLuint>(subscript));
                  break;
              }
              else if (varying->isStruct())
              {
                  GLuint fieldIndex = 0;
                  const auto *field = varying->findField(tfVaryingName, &fieldIndex);
                  if (field != nullptr)
                  {
                      mState.mExecutable->mLinkedTransformFeedbackVaryings.emplace_back(*field,
                                                                                        *varying);
                      break;
                  }
              }
          }
      }
  }
  
  ProgramMergedVaryings Program::getMergedVaryings() const
  {
      ASSERT(mState.mAttachedShaders[ShaderType::Compute] == nullptr);
  
      // Varyings are matched between pairs of consecutive stages, by location if assigned or
      // by name otherwise.  Note that it's possible for one stage to specify location and the other
      // not: https://cvs.khronos.org/bugzilla/show_bug.cgi?id=16261
  
      // Map stages to the previous active stage in the rendering pipeline.  When looking at input
      // varyings of a stage, this is used to find the stage whose output varyings are being linked
      // with them.
      ShaderMap<ShaderType> previousActiveStage;
  
      // Note that kAllGraphicsShaderTypes is sorted according to the rendering pipeline.
      ShaderType lastActiveStage = ShaderType::InvalidEnum;
      for (ShaderType stage : kAllGraphicsShaderTypes)
      {
          previousActiveStage[stage] = lastActiveStage;
          if (mState.mAttachedShaders[stage])
          {
              lastActiveStage = stage;
          }
      }
  
      // First, go through output varyings and create two maps (one by name, one by location) for
      // faster lookup when matching input varyings.
  
      ShaderMap<std::map<std::string, size_t>> outputVaryingNameToIndex;
      ShaderMap<std::map<int, size_t>> outputVaryingLocationToIndex;
  
      ProgramMergedVaryings merged;
  
      // Gather output varyings.
      for (Shader *shader : mState.mAttachedShaders)
      {
          if (!shader)
          {
              continue;
          }
          ShaderType stage = shader->getType();
  
          for (const sh::ShaderVariable &varying : shader->getOutputVaryings())
          {
              merged.push_back({});
              ProgramVaryingRef *ref = &merged.back();
  
              ref->frontShader      = &varying;
              ref->frontShaderStage = stage;
  
              // Always map by name.  Even if location is provided in this stage, it may not be in the
              // paired stage.
              outputVaryingNameToIndex[stage][varying.name] = merged.size() - 1;
  
              // If location is provided, also keep it in a map by location.
              if (varying.location != -1)
              {
                  outputVaryingLocationToIndex[stage][varying.location] = merged.size() - 1;
              }
          }
      }
  
      // Gather input varyings, and match them with output varyings of the previous stage.
      for (Shader *shader : mState.mAttachedShaders)
      {
          if (!shader)
          {
              continue;
          }
          ShaderType stage         = shader->getType();
          ShaderType previousStage = previousActiveStage[stage];
  
          for (const sh::ShaderVariable &varying : shader->getInputVaryings())
          {
              size_t mergedIndex = merged.size();
              if (previousStage != ShaderType::InvalidEnum)
              {
                  // If location is provided, see if we can match by location.
                  if (varying.location != -1)
                  {
                      auto byLocationIter =
                          outputVaryingLocationToIndex[previousStage].find(varying.location);
                      if (byLocationIter != outputVaryingLocationToIndex[previousStage].end())
                      {
                          mergedIndex = byLocationIter->second;
                      }
                  }
  
                  // If not found, try to match by name.
                  if (mergedIndex == merged.size())
                  {
                      auto byNameIter = outputVaryingNameToIndex[previousStage].find(varying.name);
                      if (byNameIter != outputVaryingNameToIndex[previousStage].end())
                      {
                          mergedIndex = byNameIter->second;
                      }
                  }
              }
  
              // If no previous stage, or not matched by location or name, create a new entry for it.
              if (mergedIndex == merged.size())
              {
                  merged.push_back({});
                  mergedIndex = merged.size() - 1;
              }
  
              ProgramVaryingRef *ref = &merged[mergedIndex];
  
              ref->backShader      = &varying;
              ref->backShaderStage = stage;
          }
      }
  
      return merged;
  }
  
  bool CompareOutputVariable(const sh::ShaderVariable &a, const sh::ShaderVariable &b)
  {
      return a.getArraySizeProduct() > b.getArraySizeProduct();
  }
  
  int Program::getOutputLocationForLink(const sh::ShaderVariable &outputVariable) const
  {
      if (outputVariable.location != -1)
      {
          return outputVariable.location;
      }
      int apiLocation = mFragmentOutputLocations.getBinding(outputVariable);
      if (apiLocation != -1)
      {
          return apiLocation;
      }
      return -1;
  }
  
  bool Program::isOutputSecondaryForLink(const sh::ShaderVariable &outputVariable) const
  {
      if (outputVariable.index != -1)
      {
          ASSERT(outputVariable.index == 0 || outputVariable.index == 1);
          return (outputVariable.index == 1);
      }
      int apiIndex = mFragmentOutputIndexes.getBinding(outputVariable);
      if (apiIndex != -1)
      {
          // Index layout qualifier from the shader takes precedence, so the index from the API is
          // checked only if the index was not set in the shader. This is not specified in the EXT
          // spec, but is specified in desktop OpenGL specs.
          return (apiIndex == 1);
      }
      // EXT_blend_func_extended: Outputs get index 0 by default.
      return false;
  }
  
  namespace
  {
  
  bool FindUsedOutputLocation(std::vector<VariableLocation> &outputLocations,
                              unsigned int baseLocation,
                              unsigned int elementCount,
                              const std::vector<VariableLocation> &reservedLocations,
                              unsigned int variableIndex)
  {
      if (baseLocation + elementCount > outputLocations.size())
      {
          elementCount = baseLocation < outputLocations.size()
                             ? static_cast<unsigned int>(outputLocations.size() - baseLocation)
                             : 0;
      }
      for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++)
      {
          const unsigned int location = baseLocation + elementIndex;
          if (outputLocations[location].used())
          {
              VariableLocation locationInfo(elementIndex, variableIndex);
              if (std::find(reservedLocations.begin(), reservedLocations.end(), locationInfo) ==
                  reservedLocations.end())
              {
                  return true;
              }
          }
      }
      return false;
  }
  
  void AssignOutputLocations(std::vector<VariableLocation> &outputLocations,
                             unsigned int baseLocation,
                             unsigned int elementCount,
                             const std::vector<VariableLocation> &reservedLocations,
                             unsigned int variableIndex,
                             sh::ShaderVariable &outputVariable)
  {
      if (baseLocation + elementCount > outputLocations.size())
      {
          outputLocations.resize(baseLocation + elementCount);
      }
      for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++)
      {
          VariableLocation locationInfo(elementIndex, variableIndex);
          if (std::find(reservedLocations.begin(), reservedLocations.end(), locationInfo) ==
              reservedLocations.end())
          {
              outputVariable.location     = baseLocation;
              const unsigned int location = baseLocation + elementIndex;
              outputLocations[location]   = locationInfo;
          }
      }
  }
  
  }  // anonymous namespace
  
  bool Program::linkOutputVariables(const Caps &caps,
                                    const Extensions &extensions,
                                    const Version &version,
                                    GLuint combinedImageUniformsCount,
                                    GLuint combinedShaderStorageBlocksCount)
  {
      InfoLog &infoLog       = mState.mExecutable->getInfoLog();
      Shader *fragmentShader = mState.mAttachedShaders[ShaderType::Fragment];
  
      ASSERT(mState.mOutputVariableTypes.empty());
      ASSERT(mState.mActiveOutputVariables.none());
      ASSERT(mState.mDrawBufferTypeMask.none());
  
      if (!fragmentShader)
      {
          // No fragment shader, so nothing to link
          return true;
      }
  
      const auto &outputVariables = fragmentShader->getActiveOutputVariables();
  
      // 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);
              ComponentType componentType =
                  GLenumToComponentType(mState.mOutputVariableTypes[location]);
              SetComponentTypeMask(componentType, location, &mState.mDrawBufferTypeMask);
          }
      }
  
      if (version >= 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() >
              static_cast<GLuint>(caps.maxCombinedShaderOutputResources))
          {
              infoLog
                  << "The sum of the number of active image uniforms, active shader storage blocks "
                     "and active fragment shader outputs exceeds "
                     "MAX_COMBINED_SHADER_OUTPUT_RESOURCES ("
                  << caps.maxCombinedShaderOutputResources << ")";
              return false;
          }
      }
  
      // Skip this step for GLES2 shaders.
      if (fragmentShader && fragmentShader->getShaderVersion() == 100)
          return true;
  
      mState.mExecutable->mOutputVariables = outputVariables;
      // TODO(jmadill): any caps validation here?
  
      // EXT_blend_func_extended doesn't specify anything related to binding specific elements of an
      // output array in explicit terms.
      //
      // Assuming fragData is an output array, you can defend the position that:
      // P1) you must support binding "fragData" because it's specified
      // P2) you must support querying "fragData[x]" because it's specified
      // P3) you must support binding "fragData[0]" because it's a frequently used pattern
      //
      // Then you can make the leap of faith:
      // P4) you must support binding "fragData[x]" because you support "fragData[0]"
      // P5) you must support binding "fragData[x]" because you support querying "fragData[x]"
      //
      // The spec brings in the "world of arrays" when it mentions binding the arrays and the
      // automatic binding. Thus it must be interpreted that the thing is not undefined, rather you
      // must infer the only possible interpretation (?). Note again: this need of interpretation
      // might be completely off of what GL spec logic is.
      //
      // The other complexity is that unless you implement this feature, it's hard to understand what
      // should happen when the client invokes the feature. You cannot add an additional error as it
      // is not specified. One can ignore it, but obviously it creates the discrepancies...
  
      std::vector<VariableLocation> reservedLocations;
  
      // Process any output API bindings for arrays that don't alias to the first element.
      for (const auto &binding : mFragmentOutputLocations)
      {
          size_t nameLengthWithoutArrayIndex;
          unsigned int arrayIndex = ParseArrayIndex(binding.first, &nameLengthWithoutArrayIndex);
          if (arrayIndex == 0 || arrayIndex == GL_INVALID_INDEX)
          {
              continue;
          }
          for (unsigned int outputVariableIndex = 0;
               outputVariableIndex < mState.mExecutable->getOutputVariables().size();
               outputVariableIndex++)
          {
              const sh::ShaderVariable &outputVariable =
                  mState.mExecutable->getOutputVariables()[outputVariableIndex];
              // Check that the binding corresponds to an output array and its array index fits.
              if (outputVariable.isBuiltIn() || !outputVariable.isArray() ||
                  !angle::BeginsWith(outputVariable.name, binding.first,
                                     nameLengthWithoutArrayIndex) ||
                  arrayIndex >= outputVariable.getOutermostArraySize())
              {
                  continue;
              }
  
              // Get the API index that corresponds to this exact binding.
              // This index may differ from the index used for the array's base.
              auto &outputLocations = mFragmentOutputIndexes.getBindingByName(binding.first) == 1
                                          ? mState.mSecondaryOutputLocations
                                          : mState.mExecutable->mOutputLocations;
              unsigned int location = binding.second.location;
              VariableLocation locationInfo(arrayIndex, outputVariableIndex);
              if (location >= outputLocations.size())
              {
                  outputLocations.resize(location + 1);
              }
              if (outputLocations[location].used())
              {
                  infoLog << "Location of variable " << outputVariable.name
                          << " conflicts with another variable.";
                  return false;
              }
              outputLocations[location] = locationInfo;
  
              // Note the array binding location so that it can be skipped later.
              reservedLocations.push_back(locationInfo);
          }
      }
  
      // Reserve locations for output variables whose location is fixed in the shader or through the
      // API. Otherwise, the remaining unallocated outputs will be processed later.
      for (unsigned int outputVariableIndex = 0;
           outputVariableIndex < mState.mExecutable->getOutputVariables().size();
           outputVariableIndex++)
      {
          const sh::ShaderVariable &outputVariable =
              mState.mExecutable->getOutputVariables()[outputVariableIndex];
  
          // Don't store outputs for gl_FragDepth, gl_FragColor, etc.
          if (outputVariable.isBuiltIn())
              continue;
  
          int fixedLocation = getOutputLocationForLink(outputVariable);
          if (fixedLocation == -1)
          {
              // Here we're only reserving locations for variables whose location is fixed.
              continue;
          }
          unsigned int baseLocation = static_cast<unsigned int>(fixedLocation);
  
          auto &outputLocations = isOutputSecondaryForLink(outputVariable)
                                      ? mState.mSecondaryOutputLocations
                                      : mState.mExecutable->mOutputLocations;
  
          // 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();
          if (FindUsedOutputLocation(outputLocations, baseLocation, elementCount, reservedLocations,
                                     outputVariableIndex))
          {
              infoLog << "Location of variable " << outputVariable.name
                      << " conflicts with another variable.";
              return false;
          }
          AssignOutputLocations(outputLocations, baseLocation, elementCount, reservedLocations,
                                outputVariableIndex,
                                mState.mExecutable->mOutputVariables[outputVariableIndex]);
      }
  
      // Here we assign locations for the output variables that don't yet have them. Note that we're
      // not necessarily able to fit the variables optimally, since then we might have to try
      // different arrangements of output arrays. Now we just assign the locations in the order that
      // we got the output variables. The spec isn't clear on what kind of algorithm is required for
      // finding locations for the output variables, so this should be acceptable at least for now.
      GLuint maxLocation = static_cast<GLuint>(caps.maxDrawBuffers);
      if (!mState.mSecondaryOutputLocations.empty())
      {
          // EXT_blend_func_extended: Program outputs will be validated against
          // MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT if there's even one output with index one.
          maxLocation = extensions.maxDualSourceDrawBuffers;
      }
  
      for (unsigned int outputVariableIndex = 0;
           outputVariableIndex < mState.mExecutable->getOutputVariables().size();
           outputVariableIndex++)
      {
          const sh::ShaderVariable &outputVariable =
              mState.mExecutable->getOutputVariables()[outputVariableIndex];
  
          // Don't store outputs for gl_FragDepth, gl_FragColor, etc.
          if (outputVariable.isBuiltIn())
              continue;
  
          int fixedLocation     = getOutputLocationForLink(outputVariable);
          auto &outputLocations = isOutputSecondaryForLink(outputVariable)
                                      ? mState.mSecondaryOutputLocations
                                      : mState.mExecutable->mOutputLocations;
          unsigned int baseLocation = 0;
          unsigned int elementCount = outputVariable.getBasicTypeElementCount();
          if (fixedLocation != -1)
          {
              // Secondary inputs might have caused the max location to drop below what has already
              // been explicitly assigned locations. Check for any fixed locations above the max
              // that should cause linking to fail.
              baseLocation = static_cast<unsigned int>(fixedLocation);
          }
          else
          {
              // No fixed location, so try to fit the output in unassigned locations.
              // Try baseLocations starting from 0 one at a time and see if the variable fits.
              while (FindUsedOutputLocation(outputLocations, baseLocation, elementCount,
                                            reservedLocations, outputVariableIndex))
              {
                  baseLocation++;
              }
              AssignOutputLocations(outputLocations, baseLocation, elementCount, reservedLocations,
                                    outputVariableIndex,
                                    mState.mExecutable->mOutputVariables[outputVariableIndex]);
          }
  
          // Check for any elements assigned above the max location that are actually used.
          if (baseLocation + elementCount > maxLocation &&
              (baseLocation >= maxLocation ||
               FindUsedOutputLocation(outputLocations, maxLocation,
                                      baseLocation + elementCount - maxLocation, reservedLocations,
                                      outputVariableIndex)))
          {
              // EXT_blend_func_extended: Linking can fail:
              // "if the explicit binding assignments do not leave enough space for the linker to
              // automatically assign a location for a varying out array, which requires multiple
              // contiguous locations."
              infoLog << "Could not fit output variable into available locations: "
                      << outputVariable.name;
              return false;
          }
      }
  
      return true;
  }
  
  void Program::setUniformValuesFromBindingQualifiers()
  {
      for (unsigned int samplerIndex : mState.mExecutable->getSamplerUniformRange())
      {
          const auto &samplerUniform = mState.mExecutable->getUniforms()[samplerIndex];
          if (samplerUniform.binding != -1)
          {
              UniformLocation location = getUniformLocation(samplerUniform.name);
              ASSERT(location.value != -1);
              std::vector<GLint> boundTextureUnits;
              for (unsigned int elementIndex = 0;
                   elementIndex < samplerUniform.getBasicTypeElementCount(); ++elementIndex)
              {
                  boundTextureUnits.push_back(samplerUniform.binding + elementIndex);
              }
  
              // Here we pass nullptr to avoid a large chain of calls that need a non-const Context.
              // We know it's safe not to notify the Context because this is only called after link.
              setUniform1iv(nullptr, location, static_cast<GLsizei>(boundTextureUnits.size()),
                            boundTextureUnits.data());
          }
      }
  }
  
  void Program::initInterfaceBlockBindings()
  {
      // Set initial bindings from shader.
      for (unsigned int blockIndex = 0; blockIndex < mState.mExecutable->getActiveUniformBlockCount();
           blockIndex++)
      {
          InterfaceBlock &uniformBlock = mState.mExecutable->mUniformBlocks[blockIndex];
          bindUniformBlock(blockIndex, uniformBlock.binding);
      }
  }
  
  void Program::updateSamplerUniform(Context *context,
                                     const VariableLocation &locationInfo,
                                     GLsizei clampedCount,
                                     const GLint *v)
  {
      ASSERT(mState.isSamplerUniformIndex(locationInfo.index));
      GLuint samplerIndex            = mState.getSamplerIndexFromUniformIndex(locationInfo.index);
      SamplerBinding &samplerBinding = mState.mExecutable->mSamplerBindings[samplerIndex];
      std::vector<GLuint> &boundTextureUnits = samplerBinding.boundTextureUnits;
  
      if (samplerBinding.unreferenced)
          return;
  
      // Update the sampler uniforms.
      for (GLsizei arrayIndex = 0; arrayIndex < clampedCount; ++arrayIndex)
      {
          GLint oldTextureUnit = boundTextureUnits[arrayIndex + locationInfo.arrayIndex];
          GLint newTextureUnit = v[arrayIndex];
  
          if (oldTextureUnit == newTextureUnit)
              continue;
  
          boundTextureUnits[arrayIndex + locationInfo.arrayIndex] = newTextureUnit;
  
          // Update the reference counts.
          uint32_t &oldRefCount = mState.mExecutable->mActiveSamplerRefCounts[oldTextureUnit];
          uint32_t &newRefCount = mState.mExecutable->mActiveSamplerRefCounts[newTextureUnit];
          ASSERT(oldRefCount > 0);
          ASSERT(newRefCount < std::numeric_limits<uint32_t>::max());
          oldRefCount--;
          newRefCount++;
  
          // Check for binding type change.
          TextureType &newSamplerType     = mState.mExecutable->mActiveSamplerTypes[newTextureUnit];
          TextureType &oldSamplerType     = mState.mExecutable->mActiveSamplerTypes[oldTextureUnit];
          SamplerFormat &newSamplerFormat = mState.mExecutable->mActiveSamplerFormats[newTextureUnit];
          SamplerFormat &oldSamplerFormat = mState.mExecutable->mActiveSamplerFormats[oldTextureUnit];
  
          if (newRefCount == 1)
          {
              newSamplerType   = samplerBinding.textureType;
              newSamplerFormat = samplerBinding.format;
              mState.mExecutable->mActiveSamplersMask.set(newTextureUnit);
              mState.mExecutable->mActiveSamplerShaderBits[newTextureUnit] =
                  mState.mExecutable->getUniforms()[locationInfo.index].activeShaders();
          }
          else
          {
              if (newSamplerType != samplerBinding.textureType)
              {
                  // Conflict detected. Ensure we reset it properly.
                  newSamplerType = TextureType::InvalidEnum;
              }
              if (newSamplerFormat != samplerBinding.format)
              {
                  newSamplerFormat = SamplerFormat::InvalidEnum;
              }
          }
  
          // Unset previously active sampler.
          if (oldRefCount == 0)
          {
              oldSamplerType   = TextureType::InvalidEnum;
              oldSamplerFormat = SamplerFormat::InvalidEnum;
              mState.mExecutable->mActiveSamplersMask.reset(oldTextureUnit);
          }
          else
          {
              if (oldSamplerType == TextureType::InvalidEnum ||
                  oldSamplerFormat == SamplerFormat::InvalidEnum)
              {
                  // Previous conflict. Check if this new change fixed the conflict.
                  mState.setSamplerUniformTextureTypeAndFormat(oldTextureUnit);
              }
          }
  
          // Notify context.
          if (context)
          {
              context->onSamplerUniformChange(newTextureUnit);
              context->onSamplerUniformChange(oldTextureUnit);
          }
      }
  
      // Invalidate the validation cache.
      mCachedValidateSamplersResult.reset();
  }
  
  void ProgramState::setSamplerUniformTextureTypeAndFormat(size_t textureUnitIndex)
  {
      mExecutable->setSamplerUniformTextureTypeAndFormat(textureUnitIndex,
                                                         mExecutable->mSamplerBindings);
  }
  
  template <typename T>
  GLsizei Program::clampUniformCount(const VariableLocation &locationInfo,
                                     GLsizei count,
                                     int vectorSize,
                                     const T *v)
  {
      if (count == 1)
          return 1;
  
      const LinkedUniform &linkedUniform = mState.mExecutable->getUniforms()[locationInfo.index];
  
      // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array
      // element index used, as reported by GetActiveUniform, will be ignored by the GL."
      unsigned int remainingElements =
          linkedUniform.getBasicTypeElementCount() - locationInfo.arrayIndex;
      GLsizei maxElementCount =
          static_cast<GLsizei>(remainingElements * linkedUniform.getElementComponents());
  
      if (count * vectorSize > maxElementCount)
      {
          return maxElementCount / vectorSize;
      }
  
      return count;
  }
  
  template <size_t cols, size_t rows, typename T>
  GLsizei Program::clampMatrixUniformCount(UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const T *v)
  {
      const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
  
      if (!transpose)
      {
          return clampUniformCount(locationInfo, count, cols * rows, v);
      }
  
      const LinkedUniform &linkedUniform = mState.mExecutable->getUniforms()[locationInfo.index];
  
      // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array
      // element index used, as reported by GetActiveUniform, will be ignored by the GL."
      unsigned int remainingElements =
          linkedUniform.getBasicTypeElementCount() - locationInfo.arrayIndex;
      return std::min(count, static_cast<GLsizei>(remainingElements));
  }
  
  // Driver differences mean that doing the uniform value cast ourselves gives consistent results.
  // EG: on NVIDIA drivers, it was observed that getUniformi for MAX_INT+1 returned MIN_INT.
  template <typename DestT>
  void Program::getUniformInternal(const Context *context,
                                   DestT *dataOut,
                                   UniformLocation location,
                                   GLenum nativeType,
                                   int components) const
  {
      switch (nativeType)
      {
          case GL_BOOL:
          {
              GLint tempValue[16] = {0};
              mProgram->getUniformiv(context, location.value, tempValue);
              UniformStateQueryCastLoop<GLboolean>(
                  dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
              break;
          }
          case GL_INT:
          {
              GLint tempValue[16] = {0};
              mProgram->getUniformiv(context, location.value, tempValue);
              UniformStateQueryCastLoop<GLint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
                                               components);
              break;
          }
          case GL_UNSIGNED_INT:
          {
              GLuint tempValue[16] = {0};
              mProgram->getUniformuiv(context, location.value, tempValue);
              UniformStateQueryCastLoop<GLuint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
                                                components);
              break;
          }
          case GL_FLOAT:
          {
              GLfloat tempValue[16] = {0};
              mProgram->getUniformfv(context, location.value, tempValue);
              UniformStateQueryCastLoop<GLfloat>(
                  dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
              break;
          }
          default:
              UNREACHABLE();
              break;
      }
  }
  
  angle::Result Program::syncState(const Context *context)
  {
      if (mDirtyBits.any())
      {
          ASSERT(!mLinkingState);
          ANGLE_TRY(mProgram->syncState(context, mDirtyBits));
          mDirtyBits.reset();
      }
  
      return angle::Result::Continue;
  }
  
  angle::Result Program::serialize(const Context *context, angle::MemoryBuffer *binaryOut) const
  {
      BinaryOutputStream stream;
  
      stream.writeBytes(reinterpret_cast<const unsigned char *>(ANGLE_COMMIT_HASH),
                        ANGLE_COMMIT_HASH_SIZE);
  
      // nullptr context is supported when computing binary length.
      if (context)
      {
          stream.writeInt(context->getClientVersion().major);
          stream.writeInt(context->getClientVersion().minor);
      }
      else
      {
          stream.writeInt(2);
          stream.writeInt(0);
      }
  
      const auto &computeLocalSize = mState.getComputeShaderLocalSize();
  
      stream.writeInt(computeLocalSize[0]);
      stream.writeInt(computeLocalSize[1]);
      stream.writeInt(computeLocalSize[2]);
  
      ASSERT(mState.mGeometryShaderInvocations >= 1 && mState.mGeometryShaderMaxVertices >= 0);
      stream.writeEnum(mState.mGeometryShaderInputPrimitiveType);
      stream.writeEnum(mState.mGeometryShaderOutputPrimitiveType);
      stream.writeInt(mState.mGeometryShaderInvocations);
      stream.writeInt(mState.mGeometryShaderMaxVertices);
  
      stream.writeInt(mState.mNumViews);
      stream.writeInt(mState.mEarlyFramentTestsOptimization);
  
      stream.writeInt(mState.getProgramInputs().size());
      for (const sh::ShaderVariable &attrib : mState.getProgramInputs())
      {
          WriteShaderVar(&stream, attrib);
          stream.writeInt(attrib.location);
      }
  
      stream.writeInt(mState.getUniforms().size());
      for (const LinkedUniform &uniform : mState.getUniforms())
      {
          WriteShaderVar(&stream, uniform);
  
          // FIXME: referenced
  
          stream.writeInt(uniform.bufferIndex);
          WriteBlockMemberInfo(&stream, uniform.blockInfo);
  
          stream.writeIntVector(uniform.outerArraySizes);
  
          // Active shader info
          for (ShaderType shaderType : gl::AllShaderTypes())
          {
              stream.writeInt(uniform.isActive(shaderType));
          }
      }
  
      stream.writeInt(mState.getUniformLocations().size());
      for (const auto &variable : mState.getUniformLocations())
      {
          stream.writeInt(variable.arrayIndex);
          stream.writeIntOrNegOne(variable.index);
          stream.writeInt(variable.ignored);
      }
  
      stream.writeInt(mState.getUniformBlocks().size());
      for (const InterfaceBlock &uniformBlock : mState.getUniformBlocks())
      {
          WriteInterfaceBlock(&stream, uniformBlock);
      }
  
      stream.writeInt(mState.getBufferVariables().size());
      for (const BufferVariable &bufferVariable : mState.getBufferVariables())
      {
          WriteBufferVariable(&stream, bufferVariable);
      }
  
      stream.writeInt(mState.getShaderStorageBlocks().size());
      for (const InterfaceBlock &shaderStorageBlock : mState.getShaderStorageBlocks())
      {
          WriteInterfaceBlock(&stream, shaderStorageBlock);
      }
  
      stream.writeInt(mState.mExecutable->getActiveAtomicCounterBufferCount());
      for (const auto &atomicCounterBuffer : mState.mExecutable->getAtomicCounterBuffers())
      {
          WriteShaderVariableBuffer(&stream, atomicCounterBuffer);
      }
  
      // Warn the app layer if saving a binary with unsupported transform feedback.
      if (!mState.getLinkedTransformFeedbackVaryings().empty() &&
          context->getFrontendFeatures().disableProgramCachingForTransformFeedback.enabled)
      {
          WARN() << "Saving program binary with transform feedback, which is not supported on this "
                    "driver.";
      }
  
      stream.writeInt(mState.getLinkedTransformFeedbackVaryings().size());
      for (const auto &var : mState.getLinkedTransformFeedbackVaryings())
      {
          stream.writeIntVector(var.arraySizes);
          stream.writeInt(var.type);
          stream.writeString(var.name);
  
          stream.writeIntOrNegOne(var.arrayIndex);
      }
  
      stream.writeInt(mState.getTransformFeedbackBufferMode());
  
      stream.writeInt(mState.getOutputVariables().size());
      for (const sh::ShaderVariable &output : mState.getOutputVariables())
      {
          WriteShaderVar(&stream, output);
          stream.writeInt(output.location);
          stream.writeInt(output.index);
      }
  
      stream.writeInt(mState.getOutputLocations().size());
      for (const auto &outputVar : mState.getOutputLocations())
      {
          stream.writeInt(outputVar.arrayIndex);
          stream.writeIntOrNegOne(outputVar.index);
          stream.writeInt(outputVar.ignored);
      }
  
      stream.writeInt(mState.getSecondaryOutputLocations().size());
      for (const auto &outputVar : mState.getSecondaryOutputLocations())
      {
          stream.writeInt(outputVar.arrayIndex);
          stream.writeIntOrNegOne(outputVar.index);
          stream.writeInt(outputVar.ignored);
      }
  
      stream.writeInt(mState.mOutputVariableTypes.size());
      for (const auto &outputVariableType : mState.mOutputVariableTypes)
      {
          stream.writeInt(outputVariableType);
      }
  
      static_assert(
          IMPLEMENTATION_MAX_DRAW_BUFFERS * 2 <= 8 * sizeof(uint32_t),
          "All bits of mDrawBufferTypeMask and mActiveOutputVariables can be contained in 32 bits");
      stream.writeInt(static_cast<int>(mState.mDrawBufferTypeMask.to_ulong()));
      stream.writeInt(static_cast<int>(mState.mActiveOutputVariables.to_ulong()));
  
      stream.writeInt(mState.getDefaultUniformRange().low());
      stream.writeInt(mState.getDefaultUniformRange().high());
  
      stream.writeInt(mState.getSamplerUniformRange().low());
      stream.writeInt(mState.getSamplerUniformRange().high());
  
      stream.writeInt(mState.getSamplerBindings().size());
      for (const auto &samplerBinding : mState.getSamplerBindings())
      {
          stream.writeEnum(samplerBinding.textureType);
          stream.writeEnum(samplerBinding.format);
          stream.writeInt(samplerBinding.boundTextureUnits.size());
          stream.writeInt(samplerBinding.unreferenced);
      }
  
      stream.writeInt(mState.getImageUniformRange().low());
      stream.writeInt(mState.getImageUniformRange().high());
  
      stream.writeInt(mState.getImageBindings().size());
      for (const auto &imageBinding : mState.getImageBindings())
      {
          stream.writeInt(imageBinding.boundImageUnits.size());
          for (size_t i = 0; i < imageBinding.boundImageUnits.size(); ++i)
          {
              stream.writeInt(imageBinding.boundImageUnits[i]);
          }
      }
  
      stream.writeInt(mState.getAtomicCounterUniformRange().low());
      stream.writeInt(mState.getAtomicCounterUniformRange().high());
  
      mState.mExecutable->save(&stream);
  
      mProgram->save(context, &stream);
  
      ASSERT(binaryOut);
      if (!binaryOut->resize(stream.length()))
      {
          WARN() << "Failed to allocate enough memory to serialize a program. (" << stream.length()
                 << " bytes )";
          return angle::Result::Incomplete;
      }
      memcpy(binaryOut->data(), stream.data(), stream.length());
      return angle::Result::Continue;
  }
  
  angle::Result Program::deserialize(const Context *context,
                                     BinaryInputStream &stream,
                                     InfoLog &infoLog)
  {
      unsigned char commitString[ANGLE_COMMIT_HASH_SIZE];
      stream.readBytes(commitString, ANGLE_COMMIT_HASH_SIZE);
      if (memcmp(commitString, ANGLE_COMMIT_HASH, sizeof(unsigned char) * ANGLE_COMMIT_HASH_SIZE) !=
          0)
      {
          infoLog << "Invalid program binary version.";
          return angle::Result::Incomplete;
      }
  
      int majorVersion = stream.readInt<int>();
      int minorVersion = stream.readInt<int>();
      if (majorVersion != context->getClientMajorVersion() ||
          minorVersion != context->getClientMinorVersion())
      {
          infoLog << "Cannot load program binaries across different ES context versions.";
          return angle::Result::Incomplete;
      }
  
      mState.mComputeShaderLocalSize[0] = stream.readInt<int>();
      mState.mComputeShaderLocalSize[1] = stream.readInt<int>();
      mState.mComputeShaderLocalSize[2] = stream.readInt<int>();
  
      mState.mGeometryShaderInputPrimitiveType  = stream.readEnum<PrimitiveMode>();
      mState.mGeometryShaderOutputPrimitiveType = stream.readEnum<PrimitiveMode>();
      mState.mGeometryShaderInvocations         = stream.readInt<int>();
      mState.mGeometryShaderMaxVertices         = stream.readInt<int>();
  
      mState.mNumViews                      = stream.readInt<int>();
      mState.mEarlyFramentTestsOptimization = stream.readInt<bool>();
  
      unsigned int attribCount = stream.readInt<unsigned int>();
      ASSERT(mState.mExecutable->getProgramInputs().empty());
      for (unsigned int attribIndex = 0; attribIndex < attribCount; ++attribIndex)
      {
          sh::ShaderVariable attrib;
          LoadShaderVar(&stream, &attrib);
          attrib.location = stream.readInt<int>();
          mState.mExecutable->mProgramInputs.push_back(attrib);
      }
  
      unsigned int uniformCount = stream.readInt<unsigned int>();
      ASSERT(mState.mExecutable->getUniforms().empty());
      for (unsigned int uniformIndex = 0; uniformIndex < uniformCount; ++uniformIndex)
      {
          LinkedUniform uniform;
          LoadShaderVar(&stream, &uniform);
  
          uniform.bufferIndex = stream.readInt<int>();
          LoadBlockMemberInfo(&stream, &uniform.blockInfo);
  
          stream.readIntVector<unsigned int>(&uniform.outerArraySizes);
  
          uniform.typeInfo = &GetUniformTypeInfo(uniform.type);
  
          // Active shader info
          for (ShaderType shaderType : gl::AllShaderTypes())
          {
              uniform.setActive(shaderType, stream.readBool());
          }
  
          mState.mExecutable->mUniforms.push_back(uniform);
      }
  
      const unsigned int uniformIndexCount = stream.readInt<unsigned int>();
      ASSERT(mState.mUniformLocations.empty());
      for (unsigned int uniformIndexIndex = 0; uniformIndexIndex < uniformIndexCount;
           uniformIndexIndex++)
      {
          VariableLocation variable;
          stream.readInt(&variable.arrayIndex);
          stream.readInt(&variable.index);
          stream.readBool(&variable.ignored);
  
          mState.mUniformLocations.push_back(variable);
      }
  
      unsigned int uniformBlockCount = stream.readInt<unsigned int>();
      ASSERT(mState.mExecutable->getUniformBlocks().empty());
      for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < uniformBlockCount;
           ++uniformBlockIndex)
      {
          InterfaceBlock uniformBlock;
          LoadInterfaceBlock(&stream, &uniformBlock);
          mState.mExecutable->mUniformBlocks.push_back(uniformBlock);
  
          mState.mActiveUniformBlockBindings.set(uniformBlockIndex, uniformBlock.binding != 0);
      }
  
      unsigned int bufferVariableCount = stream.readInt<unsigned int>();
      ASSERT(mState.mBufferVariables.empty());
      for (unsigned int index = 0; index < bufferVariableCount; ++index)
      {
          BufferVariable bufferVariable;
          LoadBufferVariable(&stream, &bufferVariable);
          mState.mBufferVariables.push_back(bufferVariable);
      }
  
      unsigned int shaderStorageBlockCount = stream.readInt<unsigned int>();
      ASSERT(mState.mExecutable->getShaderStorageBlocks().empty());
      for (unsigned int shaderStorageBlockIndex = 0;
           shaderStorageBlockIndex < shaderStorageBlockCount; ++shaderStorageBlockIndex)
      {
          InterfaceBlock shaderStorageBlock;
          LoadInterfaceBlock(&stream, &shaderStorageBlock);
          mState.mExecutable->mShaderStorageBlocks.push_back(shaderStorageBlock);
      }
  
      unsigned int atomicCounterBufferCount = stream.readInt<unsigned int>();
      ASSERT(mState.mExecutable->getAtomicCounterBuffers().empty());
      for (unsigned int bufferIndex = 0; bufferIndex < atomicCounterBufferCount; ++bufferIndex)
      {
          AtomicCounterBuffer atomicCounterBuffer;
          LoadShaderVariableBuffer(&stream, &atomicCounterBuffer);
  
          mState.mExecutable->mAtomicCounterBuffers.push_back(atomicCounterBuffer);
      }
  
      unsigned int transformFeedbackVaryingCount = stream.readInt<unsigned int>();
  
      // Reject programs that use transform feedback varyings if the hardware cannot support them.
      if (transformFeedbackVaryingCount > 0 &&
          context->getFrontendFeatures().disableProgramCachingForTransformFeedback.enabled)
      {
          infoLog << "Current driver does not support transform feedback in binary programs.";
          return angle::Result::Incomplete;
      }
  
      ASSERT(mState.mExecutable->mLinkedTransformFeedbackVaryings.empty());
      for (unsigned int transformFeedbackVaryingIndex = 0;
           transformFeedbackVaryingIndex < transformFeedbackVaryingCount;
           ++transformFeedbackVaryingIndex)
      {
          sh::ShaderVariable varying;
          stream.readIntVector<unsigned int>(&varying.arraySizes);
          stream.readInt(&varying.type);
          stream.readString(&varying.name);
  
          GLuint arrayIndex = stream.readInt<GLuint>();
  
          mState.mExecutable->mLinkedTransformFeedbackVaryings.emplace_back(varying, arrayIndex);
      }
  
      stream.readInt(&mState.mExecutable->mTransformFeedbackBufferMode);
  
      unsigned int outputCount = stream.readInt<unsigned int>();
      ASSERT(mState.mExecutable->getOutputVariables().empty());
      for (unsigned int outputIndex = 0; outputIndex < outputCount; ++outputIndex)
      {
          sh::ShaderVariable output;
          LoadShaderVar(&stream, &output);
          output.location = stream.readInt<int>();
          output.index    = stream.readInt<int>();
          mState.mExecutable->mOutputVariables.push_back(output);
      }
  
      unsigned int outputVarCount = stream.readInt<unsigned int>();
      ASSERT(mState.mExecutable->getOutputLocations().empty());
      for (unsigned int outputIndex = 0; outputIndex < outputVarCount; ++outputIndex)
      {
          VariableLocation locationData;
          stream.readInt(&locationData.arrayIndex);
          stream.readInt(&locationData.index);
          stream.readBool(&locationData.ignored);
          mState.mExecutable->mOutputLocations.push_back(locationData);
      }
  
      unsigned int secondaryOutputVarCount = stream.readInt<unsigned int>();
      ASSERT(mState.mSecondaryOutputLocations.empty());
      for (unsigned int outputIndex = 0; outputIndex < secondaryOutputVarCount; ++outputIndex)
      {
          VariableLocation locationData;
          stream.readInt(&locationData.arrayIndex);
          stream.readInt(&locationData.index);
          stream.readBool(&locationData.ignored);
          mState.mSecondaryOutputLocations.push_back(locationData);
      }
  
      unsigned int outputTypeCount = stream.readInt<unsigned int>();
      for (unsigned int outputIndex = 0; outputIndex < outputTypeCount; ++outputIndex)
      {
          mState.mOutputVariableTypes.push_back(stream.readInt<GLenum>());
      }
  
      static_assert(IMPLEMENTATION_MAX_DRAW_BUFFERS * 2 <= 8 * sizeof(uint32_t),
                    "All bits of mDrawBufferTypeMask and mActiveOutputVariables types and mask fit "
                    "into 32 bits each");
      mState.mDrawBufferTypeMask    = gl::ComponentTypeMask(stream.readInt<uint32_t>());
      mState.mActiveOutputVariables = stream.readInt<gl::DrawBufferMask>();
  
      unsigned int defaultUniformRangeLow  = stream.readInt<unsigned int>();
      unsigned int defaultUniformRangeHigh = stream.readInt<unsigned int>();
      mState.mExecutable->mDefaultUniformRange =
          RangeUI(defaultUniformRangeLow, defaultUniformRangeHigh);
  
      unsigned int samplerRangeLow             = stream.readInt<unsigned int>();
      unsigned int samplerRangeHigh            = stream.readInt<unsigned int>();
      mState.mExecutable->mSamplerUniformRange = RangeUI(samplerRangeLow, samplerRangeHigh);
      unsigned int samplerCount                = stream.readInt<unsigned int>();
      for (unsigned int samplerIndex = 0; samplerIndex < samplerCount; ++samplerIndex)
      {
          TextureType textureType = stream.readEnum<TextureType>();
          SamplerFormat format    = stream.readEnum<SamplerFormat>();
          size_t bindingCount     = stream.readInt<size_t>();
          bool unreferenced       = stream.readBool();
          mState.mExecutable->mSamplerBindings.emplace_back(textureType, format, bindingCount,
                                                            unreferenced);
      }
  
      unsigned int imageRangeLow             = stream.readInt<unsigned int>();
      unsigned int imageRangeHigh            = stream.readInt<unsigned int>();
      mState.mExecutable->mImageUniformRange = RangeUI(imageRangeLow, imageRangeHigh);
      unsigned int imageBindingCount         = stream.readInt<unsigned int>();
      for (unsigned int imageIndex = 0; imageIndex < imageBindingCount; ++imageIndex)
      {
          unsigned int elementCount = stream.readInt<unsigned int>();
          ImageBinding imageBinding(elementCount);
          for (unsigned int i = 0; i < elementCount; ++i)
          {
              imageBinding.boundImageUnits[i] = stream.readInt<unsigned int>();
          }
          mState.mExecutable->mImageBindings.emplace_back(imageBinding);
      }
  
      unsigned int atomicCounterRangeLow  = stream.readInt<unsigned int>();
      unsigned int atomicCounterRangeHigh = stream.readInt<unsigned int>();
      mState.mAtomicCounterUniformRange   = RangeUI(atomicCounterRangeLow, atomicCounterRangeHigh);
  
      static_assert(static_cast<unsigned long>(ShaderType::EnumCount) <= sizeof(unsigned long) * 8,
                    "Too many shader types");
  
      if (!mState.mAttachedShaders[ShaderType::Compute])
      {
          mState.updateTransformFeedbackStrides();
      }
  
      mState.mExecutable->load(&stream);
  
      postResolveLink(context);
      mState.mExecutable->updateCanDrawWith();
  
      return angle::Result::Continue;
  }
  
  void Program::postResolveLink(const gl::Context *context)
  {
      mState.updateActiveSamplers();
      mState.mExecutable->updateActiveImages(getExecutable());
  
      setUniformValuesFromBindingQualifiers();
  
      if (context->getExtensions().multiDraw)
      {
          mState.mDrawIDLocation = getUniformLocation("gl_DrawID").value;
      }
  
      if (context->getExtensions().baseVertexBaseInstance)
      {
          mState.mBaseVertexLocation   = getUniformLocation("gl_BaseVertex").value;
          mState.mBaseInstanceLocation = getUniformLocation("gl_BaseInstance").value;
      }
  }
  
  void Program::fillProgramStateMap(ShaderMap<const ProgramState *> *programStatesOut)
  {
      for (ShaderType shaderType : AllShaderTypes())
      {
          (*programStatesOut)[shaderType] = nullptr;
          if (mState.getExecutable().hasLinkedShaderStage(shaderType) ||
              mState.getAttachedShader(shaderType))
          {
              (*programStatesOut)[shaderType] = &mState;
          }
      }
  }
  
  }  // namespace gl