Move ProgramState::mDefaultUniformRange to ProgramExecutable

src/libANGLE/Program.cpp

@@ -1080,7 +1080,6 @@ ProgramState::ProgramState()
     : mLabel(),
       mAttachedShaders{},
       mAttachedShadersMarkedForDetach{},
-      mDefaultUniformRange(0, 0),
       mAtomicCounterUniformRange(0, 0),
       mBinaryRetrieveableHint(false),
       mSeparable(false),
@@ -3751,7 +3750,7 @@ void Program::linkSamplerAndImageBindings(GLuint *combinedImageUniforms)
     }
 
     // Whatever is left constitutes the default uniforms.
-    mState.mDefaultUniformRange = RangeUI(0, low);
+    mState.mExecutable->mDefaultUniformRange = RangeUI(0, low);
 }
 
 bool Program::linkAtomicCounterBuffers()
@@ -5488,7 +5487,8 @@ angle::Result Program::deserialize(const Context *context,
 
     unsigned int defaultUniformRangeLow  = stream.readInt<unsigned int>();
     unsigned int defaultUniformRangeHigh = stream.readInt<unsigned int>();
-    mState.mDefaultUniformRange          = RangeUI(defaultUniformRangeLow, defaultUniformRangeHigh);
+    mState.mExecutable->mDefaultUniformRange =
+        RangeUI(defaultUniformRangeLow, defaultUniformRangeHigh);
 
     unsigned int samplerRangeLow             = stream.readInt<unsigned int>();
     unsigned int samplerRangeHigh            = stream.readInt<unsigned int>();

src/libANGLE/Program.h

@@ -261,7 +261,7 @@ class ProgramState final : angle::NonCopyable
     const std::vector<SamplerBinding> &getSamplerBindings() const { return mSamplerBindings; }
     const std::vector<ImageBinding> &getImageBindings() const { return mImageBindings; }
     const sh::WorkGroupSize &getComputeShaderLocalSize() const { return mComputeShaderLocalSize; }
-    const RangeUI &getDefaultUniformRange() const { return mDefaultUniformRange; }
+    const RangeUI &getDefaultUniformRange() const { return mExecutable->getDefaultUniformRange(); }
     const RangeUI &getSamplerUniformRange() const { return mExecutable->getSamplerUniformRange(); }
     const RangeUI &getImageUniformRange() const { return mExecutable->getImageUniformRange(); }
     const RangeUI &getAtomicCounterUniformRange() const { return mAtomicCounterUniformRange; }
@@ -316,7 +316,6 @@ class ProgramState final : angle::NonCopyable
         return *mExecutable;
     }
 
-    bool hasDefaultUniforms() const { return !getDefaultUniformRange().empty(); }
     bool hasTextures() const { return !getSamplerBindings().empty(); }
     bool hasImages() const { return !getImageBindings().empty(); }
     bool hasEarlyFragmentTestsOptimization() const { return mEarlyFramentTestsOptimization; }
@@ -358,7 +357,6 @@ class ProgramState final : angle::NonCopyable
 
     std::vector<VariableLocation> mUniformLocations;
     std::vector<BufferVariable> mBufferVariables;
-    RangeUI mDefaultUniformRange;
     RangeUI mAtomicCounterUniformRange;
 
     // An array of the samplers that are used by the program

src/libANGLE/ProgramExecutable.cpp

@@ -27,6 +27,7 @@ ProgramExecutable::ProgramExecutable()
       mActiveImagesMask(0),
       mCanDrawWith(false),
       mTransformFeedbackBufferMode(GL_INTERLEAVED_ATTRIBS),
+      mDefaultUniformRange(0, 0),
       mSamplerUniformRange(0, 0),
       mImageUniformRange(0, 0),
       mPipelineHasGraphicsUniformBuffers(false),
@@ -34,7 +35,9 @@ ProgramExecutable::ProgramExecutable()
       mPipelineHasGraphicsStorageBuffers(false),
       mPipelineHasComputeStorageBuffers(false),
       mPipelineHasGraphicsAtomicCounterBuffers(false),
-      mPipelineHasComputeAtomicCounterBuffers(false)
+      mPipelineHasComputeAtomicCounterBuffers(false),
+      mPipelineHasGraphicsDefaultUniforms(false),
+      mPipelineHasComputeDefaultUniforms(false)
 {
     reset();
 }
@@ -63,6 +66,7 @@ ProgramExecutable::ProgramExecutable(const ProgramExecutable &other)
       mTransformFeedbackStrides(other.mTransformFeedbackStrides),
       mTransformFeedbackBufferMode(other.mTransformFeedbackBufferMode),
       mUniforms(other.mUniforms),
+      mDefaultUniformRange(other.mDefaultUniformRange),
       mSamplerUniformRange(other.mSamplerUniformRange),
       mUniformBlocks(other.mUniformBlocks),
       mAtomicCounterBuffers(other.mAtomicCounterBuffers),
@@ -73,7 +77,9 @@ ProgramExecutable::ProgramExecutable(const ProgramExecutable &other)
       mPipelineHasGraphicsStorageBuffers(other.mPipelineHasGraphicsStorageBuffers),
       mPipelineHasComputeStorageBuffers(other.mPipelineHasComputeStorageBuffers),
       mPipelineHasGraphicsAtomicCounterBuffers(other.mPipelineHasGraphicsAtomicCounterBuffers),
-      mPipelineHasComputeAtomicCounterBuffers(other.mPipelineHasComputeAtomicCounterBuffers)
+      mPipelineHasComputeAtomicCounterBuffers(other.mPipelineHasComputeAtomicCounterBuffers),
+      mPipelineHasGraphicsDefaultUniforms(other.mPipelineHasGraphicsDefaultUniforms),
+      mPipelineHasComputeDefaultUniforms(other.mPipelineHasComputeDefaultUniforms)
 {
     reset();
 }
@@ -110,6 +116,8 @@ void ProgramExecutable::reset()
     mPipelineHasComputeStorageBuffers        = false;
     mPipelineHasGraphicsAtomicCounterBuffers = false;
     mPipelineHasComputeAtomicCounterBuffers  = false;
+    mPipelineHasGraphicsDefaultUniforms      = false;
+    mPipelineHasComputeDefaultUniforms       = false;
 }
 
 void ProgramExecutable::load(gl::BinaryInputStream *stream)
@@ -131,6 +139,8 @@ void ProgramExecutable::load(gl::BinaryInputStream *stream)
     mPipelineHasComputeStorageBuffers        = stream->readBool();
     mPipelineHasGraphicsAtomicCounterBuffers = stream->readBool();
     mPipelineHasComputeAtomicCounterBuffers  = stream->readBool();
+    mPipelineHasGraphicsDefaultUniforms      = stream->readBool();
+    mPipelineHasComputeDefaultUniforms       = stream->readBool();
 }
 
 void ProgramExecutable::save(gl::BinaryOutputStream *stream) const
@@ -151,6 +161,8 @@ void ProgramExecutable::save(gl::BinaryOutputStream *stream) const
     stream->writeInt(static_cast<bool>(mPipelineHasComputeStorageBuffers));
     stream->writeInt(static_cast<bool>(mPipelineHasGraphicsAtomicCounterBuffers));
     stream->writeInt(static_cast<bool>(mPipelineHasComputeAtomicCounterBuffers));
+    stream->writeInt(static_cast<bool>(mPipelineHasGraphicsDefaultUniforms));
+    stream->writeInt(static_cast<bool>(mPipelineHasComputeDefaultUniforms));
 }
 
 const ProgramState *ProgramExecutable::getProgramState(ShaderType shaderType) const
@@ -223,16 +235,10 @@ AttributesMask ProgramExecutable::getAttributesMask() const
     return mAttributesMask;
 }
 
-// TODO: http://anglebug.com/4520: Needs  mDefaultUniformRange moved to ProgramExecutable
 bool ProgramExecutable::hasDefaultUniforms() const
 {
-    ASSERT(mProgramState || mProgramPipelineState);
-    if (mProgramState)
-    {
-        return mProgramState->hasDefaultUniforms();
-    }
-
-    return mProgramPipelineState->hasDefaultUniforms();
+    return !getDefaultUniformRange().empty() ||
+           (isCompute() ? mPipelineHasComputeDefaultUniforms : mPipelineHasGraphicsDefaultUniforms);
 }
 
 // TODO: http://anglebug.com/4520: Needs  mSamplerBindings moved to ProgramExecutable

src/libANGLE/ProgramExecutable.h

@@ -221,6 +221,7 @@ class ProgramExecutable
     const std::vector<VariableLocation> &getOutputLocations() const { return mOutputLocations; }
     const std::vector<LinkedUniform> &getUniforms() const { return mUniforms; }
     const std::vector<InterfaceBlock> &getUniformBlocks() const { return mUniformBlocks; }
+    const RangeUI &getDefaultUniformRange() const { return mDefaultUniformRange; }
     const RangeUI &getSamplerUniformRange() const { return mSamplerUniformRange; }
     const RangeUI &getImageUniformRange() const { return mImageUniformRange; }
     const std::vector<TransformFeedbackVarying> &getLinkedTransformFeedbackVaryings() const
@@ -352,6 +353,7 @@ class ProgramExecutable
     // inner array of an array of arrays. Names and mapped names of uniforms that are arrays include
     // [0] in the end. This makes implementation of queries simpler.
     std::vector<LinkedUniform> mUniforms;
+    RangeUI mDefaultUniformRange;
     RangeUI mSamplerUniformRange;
     std::vector<InterfaceBlock> mUniformBlocks;
     std::vector<AtomicCounterBuffer> mAtomicCounterBuffers;
@@ -366,6 +368,8 @@ class ProgramExecutable
     bool mPipelineHasComputeStorageBuffers;
     bool mPipelineHasGraphicsAtomicCounterBuffers;
     bool mPipelineHasComputeAtomicCounterBuffers;
+    bool mPipelineHasGraphicsDefaultUniforms;
+    bool mPipelineHasComputeDefaultUniforms;
 
     ShaderMap<std::vector<sh::ShaderVariable>> mLinkedOutputVaryings;
     ShaderMap<std::vector<sh::ShaderVariable>> mLinkedInputVaryings;

src/libANGLE/ProgramPipeline.cpp

@@ -124,20 +124,6 @@ bool ProgramPipelineState::usesShaderProgram(ShaderProgramID programId) const
     return false;
 }
 
-bool ProgramPipelineState::hasDefaultUniforms() const
-{
-    for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
-    {
-        const Program *shaderProgram = getShaderProgram(shaderType);
-        if (shaderProgram && shaderProgram->getState().hasDefaultUniforms())
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
 bool ProgramPipelineState::hasTextures() const
 {
     for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
@@ -286,7 +272,7 @@ void ProgramPipeline::updateExecutableTextures()
     }
 }
 
-void ProgramPipeline::updateHasBuffers()
+void ProgramPipeline::updateHasBooleans()
 {
     // Need to check all of the shader stages, not just linked, so we handle Compute correctly.
     for (const gl::ShaderType shaderType : kAllGraphicsShaderTypes)
@@ -308,6 +294,10 @@ void ProgramPipeline::updateHasBuffers()
             {
                 mState.mExecutable->mPipelineHasGraphicsAtomicCounterBuffers = true;
             }
+            if (executable.hasDefaultUniforms())
+            {
+                mState.mExecutable->mPipelineHasGraphicsDefaultUniforms = true;
+            }
         }
     }
 
@@ -328,6 +318,10 @@ void ProgramPipeline::updateHasBuffers()
         {
             mState.mExecutable->mPipelineHasComputeAtomicCounterBuffers = true;
         }
+        if (executable.hasDefaultUniforms())
+        {
+            mState.mExecutable->mPipelineHasComputeDefaultUniforms = true;
+        }
     }
 }
 
@@ -341,7 +335,7 @@ void ProgramPipeline::updateExecutable()
 
     // All Shader ProgramExecutable properties
     updateExecutableTextures();
-    updateHasBuffers();
+    updateHasBooleans();
 }
 
 ProgramMergedVaryings ProgramPipeline::getMergedVaryings() const

src/libANGLE/ProgramPipeline.h

@@ -66,7 +66,6 @@ class ProgramPipelineState final : angle::NonCopyable
 
     bool usesShaderProgram(ShaderProgramID program) const;
 
-    bool hasDefaultUniforms() const;
     bool hasTextures() const;
     bool hasImages() const;
 
@@ -163,7 +162,7 @@ class ProgramPipeline final : public RefCountObject<ProgramPipelineID>, public L
     void updateExecutableAttributes();
     void updateTransformFeedbackMembers();
     void updateExecutableTextures();
-    void updateHasBuffers();
+    void updateHasBooleans();
     void updateExecutable();
 
     std::unique_ptr<rx::ProgramPipelineImpl> mProgramPipelineImpl;