Move ProgramState::mImageBindings to ProgramExecutable

src/libANGLE/Program.cpp

@@ -1655,8 +1655,9 @@ void Program::resolveLinkImpl(const Context *context)
     ASSERT(mLinked);
 
     // Mark implementation-specific unreferenced uniforms as ignored.
-    mProgram->markUnusedUniformLocations(
-        &mState.mUniformLocations, &mState.mExecutable->mSamplerBindings, &mState.mImageBindings);
+    mProgram->markUnusedUniformLocations(&mState.mUniformLocations,
+                                         &mState.mExecutable->mSamplerBindings,
+                                         &mState.mExecutable->mImageBindings);
 
     // Must be called after markUnusedUniformLocations.
     postResolveLink(context);
@@ -1722,11 +1723,6 @@ void ProgramState::updateActiveSamplers()
     mExecutable->updateActiveSamplers(*this);
 }
 
-void ProgramState::updateActiveImages()
-{
-    mExecutable->updateActiveImages(mImageBindings);
-}
-
 void ProgramState::updateProgramInterfaceInputs()
 {
     const ShaderType firstAttachedShaderType = getFirstAttachedShaderStageType();
@@ -1835,7 +1831,6 @@ void Program::unlink()
     mState.mDrawBufferTypeMask.reset();
     mState.mActiveOutputVariables.reset();
     mState.mComputeShaderLocalSize.fill(1);
-    mState.mImageBindings.clear();
     mState.mNumViews                          = -1;
     mState.mGeometryShaderInputPrimitiveType  = PrimitiveMode::Triangles;
     mState.mGeometryShaderOutputPrimitiveType = PrimitiveMode::TriangleStrip;
@@ -2910,7 +2905,8 @@ GLuint Program::getImageUniformBinding(const VariableLocation &uniformLocation)
 {
     ASSERT(!mLinkingState);
     GLuint imageIndex = mState.getImageIndexFromUniformIndex(uniformLocation.index);
-    const std::vector<GLuint> &boundImageUnits = mState.mImageBindings[imageIndex].boundImageUnits;
+    const std::vector<GLuint> &boundImageUnits =
+        mState.mExecutable->mImageBindings[imageIndex].boundImageUnits;
     return boundImageUnits[uniformLocation.arrayIndex];
 }
 
@@ -3709,12 +3705,12 @@ void Program::linkSamplerAndImageBindings(GLuint *combinedImageUniforms)
         auto &imageUniform = mState.mExecutable->getUniforms()[imageIndex];
         if (imageUniform.binding == -1)
         {
-            mState.mImageBindings.emplace_back(
+            mState.mExecutable->mImageBindings.emplace_back(
                 ImageBinding(imageUniform.getBasicTypeElementCount()));
         }
         else
         {
-            mState.mImageBindings.emplace_back(
+            mState.mExecutable->mImageBindings.emplace_back(
                 ImageBinding(imageUniform.binding, imageUniform.getBasicTypeElementCount(), false));
         }
 
@@ -5510,7 +5506,7 @@ angle::Result Program::deserialize(const Context *context,
         {
             imageBinding.boundImageUnits[i] = stream.readInt<unsigned int>();
         }
-        mState.mImageBindings.emplace_back(imageBinding);
+        mState.mExecutable->mImageBindings.emplace_back(imageBinding);
     }
 
     unsigned int atomicCounterRangeLow  = stream.readInt<unsigned int>();
@@ -5536,7 +5532,7 @@ angle::Result Program::deserialize(const Context *context,
 void Program::postResolveLink(const gl::Context *context)
 {
     mState.updateActiveSamplers();
-    mState.updateActiveImages();
+    mState.mExecutable->updateActiveImages();
 
     setUniformValuesFromBindingQualifiers();
 

src/libANGLE/Program.h

@@ -262,7 +262,10 @@ class ProgramState final : angle::NonCopyable
     {
         return mExecutable->getSamplerBindings();
     }
-    const std::vector<ImageBinding> &getImageBindings() const { return mImageBindings; }
+    const std::vector<ImageBinding> &getImageBindings() const
+    {
+        return mExecutable->getImageBindings();
+    }
     const sh::WorkGroupSize &getComputeShaderLocalSize() const { return mComputeShaderLocalSize; }
     const RangeUI &getDefaultUniformRange() const { return mExecutable->getDefaultUniformRange(); }
     const RangeUI &getSamplerUniformRange() const { return mExecutable->getSamplerUniformRange(); }
@@ -337,7 +340,6 @@ class ProgramState final : angle::NonCopyable
 
     void updateTransformFeedbackStrides();
     void updateActiveSamplers();
-    void updateActiveImages();
     void updateProgramInterfaceInputs();
     void updateProgramInterfaceOutputs();
 
@@ -361,9 +363,6 @@ class ProgramState final : angle::NonCopyable
     std::vector<BufferVariable> mBufferVariables;
     RangeUI mAtomicCounterUniformRange;
 
-    // An array of the images that are used by the program
-    std::vector<ImageBinding> mImageBindings;
-
     // EXT_blend_func_extended secondary outputs (ones with index 1) in ESSL 3.00 shaders.
     std::vector<VariableLocation> mSecondaryOutputLocations;
 
@@ -706,7 +705,7 @@ class Program final : angle::NonCopyable, public LabeledObject
     const std::vector<ImageBinding> &getImageBindings() const
     {
         ASSERT(!mLinkingState);
-        return mState.mImageBindings;
+        return mState.mExecutable->getImageBindings();
     }
     const sh::WorkGroupSize &getComputeShaderLocalSize() const;
     PrimitiveMode getGeometryShaderInputPrimitiveType() const;

src/libANGLE/ProgramExecutable.cpp

@@ -39,7 +39,9 @@ ProgramExecutable::ProgramExecutable()
       mPipelineHasGraphicsDefaultUniforms(false),
       mPipelineHasComputeDefaultUniforms(false),
       mPipelineHasGraphicsTextures(false),
-      mPipelineHasComputeTextures(false)
+      mPipelineHasComputeTextures(false),
+      mPipelineHasGraphicsImages(false),
+      mPipelineHasComputeImages(false)
 {
     reset();
 }
@@ -83,7 +85,9 @@ ProgramExecutable::ProgramExecutable(const ProgramExecutable &other)
       mPipelineHasGraphicsDefaultUniforms(other.mPipelineHasGraphicsDefaultUniforms),
       mPipelineHasComputeDefaultUniforms(other.mPipelineHasComputeDefaultUniforms),
       mPipelineHasGraphicsTextures(other.mPipelineHasGraphicsTextures),
-      mPipelineHasComputeTextures(other.mPipelineHasComputeTextures)
+      mPipelineHasComputeTextures(other.mPipelineHasComputeTextures),
+      mPipelineHasGraphicsImages(other.mPipelineHasGraphicsImages),
+      mPipelineHasComputeImages(other.mPipelineHasComputeImages)
 {
     reset();
 }
@@ -114,6 +118,7 @@ void ProgramExecutable::reset()
     mOutputVariables.clear();
     mOutputLocations.clear();
     mSamplerBindings.clear();
+    mImageBindings.clear();
 
     mPipelineHasGraphicsUniformBuffers       = false;
     mPipelineHasComputeUniformBuffers        = false;
@@ -279,16 +284,10 @@ bool ProgramExecutable::hasAtomicCounterBuffers() const
                         : mPipelineHasGraphicsAtomicCounterBuffers);
 }
 
-// TODO: http://anglebug.com/4520: Needs  mImageBindings moved to ProgramExecutable
 bool ProgramExecutable::hasImages() const
 {
-    ASSERT(mProgramState || mProgramPipelineState);
-    if (mProgramState)
-    {
-        return mProgramState->hasImages();
-    }
-
-    return mProgramPipelineState->hasImages();
+    return !getImageBindings().empty() ||
+           (isCompute() ? mPipelineHasComputeImages : mPipelineHasGraphicsImages);
 }
 
 void ProgramExecutable::updateActiveSamplers(const ProgramState &programState)
@@ -328,14 +327,15 @@ void ProgramExecutable::updateActiveSamplers(const ProgramState &programState)
     }
 }
 
-void ProgramExecutable::updateActiveImages(std::vector<ImageBinding> &imageBindings)
+void ProgramExecutable::updateActiveImages()
 {
-    const bool compute = isCompute() ? true : false;
-    for (uint32_t imageIndex = 0; imageIndex < imageBindings.size(); ++imageIndex)
+    for (uint32_t imageIndex = 0; imageIndex < mImageBindings.size(); ++imageIndex)
     {
-        const gl::ImageBinding &imageBinding = imageBindings[imageIndex];
+        const gl::ImageBinding &imageBinding = mImageBindings[imageIndex];
         if (imageBinding.unreferenced)
+        {
             continue;
+        }
 
         uint32_t uniformIndex = mProgramState->getUniformIndexFromImageIndex(imageIndex);
         const gl::LinkedUniform &imageUniform = mProgramState->getUniforms()[uniformIndex];
@@ -343,10 +343,14 @@ void ProgramExecutable::updateActiveImages(std::vector<ImageBinding> &imageBindi
         for (GLint imageUnit : imageBinding.boundImageUnits)
         {
             mActiveImagesMask.set(imageUnit);
-            if (compute)
+            if (isCompute())
+            {
                 mActiveImageShaderBits[imageUnit].set(gl::ShaderType::Compute);
+            }
             else
+            {
                 mActiveImageShaderBits[imageUnit] = shaderBits;
+            }
         }
     }
 }

src/libANGLE/ProgramExecutable.h

@@ -222,6 +222,7 @@ class ProgramExecutable
     const std::vector<LinkedUniform> &getUniforms() const { return mUniforms; }
     const std::vector<InterfaceBlock> &getUniformBlocks() const { return mUniformBlocks; }
     const std::vector<SamplerBinding> &getSamplerBindings() const { return mSamplerBindings; }
+    const std::vector<ImageBinding> &getImageBindings() const { return mImageBindings; }
     const RangeUI &getDefaultUniformRange() const { return mDefaultUniformRange; }
     const RangeUI &getSamplerUniformRange() const { return mSamplerUniformRange; }
     const RangeUI &getImageUniformRange() const { return mImageUniformRange; }
@@ -298,7 +299,7 @@ class ProgramExecutable
     friend class ProgramState;
 
     void updateActiveSamplers(const ProgramState &programState);
-    void updateActiveImages(std::vector<ImageBinding> &imageBindings);
+    void updateActiveImages();
 
     // Scans the sampler bindings for type conflicts with sampler 'textureUnitIndex'.
     void setSamplerUniformTextureTypeAndFormat(size_t textureUnitIndex,
@@ -364,6 +365,9 @@ class ProgramExecutable
     // An array of the samplers that are used by the program
     std::vector<SamplerBinding> mSamplerBindings;
 
+    // An array of the images that are used by the program
+    std::vector<ImageBinding> mImageBindings;
+
     // TODO: http://anglebug.com/3570: Remove mPipelineHas*UniformBuffers once PPO's have valid data
     // in mUniformBlocks
     bool mPipelineHasGraphicsUniformBuffers;
@@ -376,6 +380,8 @@ class ProgramExecutable
     bool mPipelineHasComputeDefaultUniforms;
     bool mPipelineHasGraphicsTextures;
     bool mPipelineHasComputeTextures;
+    bool mPipelineHasGraphicsImages;
+    bool mPipelineHasComputeImages;
 
     ShaderMap<std::vector<sh::ShaderVariable>> mLinkedOutputVaryings;
     ShaderMap<std::vector<sh::ShaderVariable>> mLinkedInputVaryings;

src/libANGLE/ProgramPipeline.cpp

@@ -288,6 +288,10 @@ void ProgramPipeline::updateHasBooleans()
             {
                 mState.mExecutable->mPipelineHasGraphicsTextures = true;
             }
+            if (executable.hasImages())
+            {
+                mState.mExecutable->mPipelineHasGraphicsImages = true;
+            }
         }
     }
 
@@ -316,6 +320,10 @@ void ProgramPipeline::updateHasBooleans()
         {
             mState.mExecutable->mPipelineHasComputeTextures = true;
         }
+        if (executable.hasImages())
+        {
+            mState.mExecutable->mPipelineHasComputeImages = true;
+        }
     }
 }