Remove ProgramExecutable::mProgram[Pipeline]State

src/libANGLE/Program.cpp

@@ -1097,8 +1097,6 @@ ProgramState::ProgramState()
       mExecutable(new ProgramExecutable())
 {
     mComputeShaderLocalSize.fill(1);
-
-    mExecutable->setProgramState(this);
 }
 
 ProgramState::~ProgramState()
@@ -1552,7 +1550,9 @@ angle::Result Program::linkImpl(const Context *context)
             return angle::Result::Continue;
         }
 
-        if (!mState.mExecutable->linkValidateGlobalNames(infoLog))
+        gl::ShaderMap<const gl::ProgramState *> programStates;
+        fillProgramStateMap(&programStates);
+        if (!mState.mExecutable->linkValidateGlobalNames(infoLog, programStates))
         {
             return angle::Result::Continue;
         }
@@ -1610,7 +1610,7 @@ angle::Result Program::linkImpl(const Context *context)
     // later linkProgram() that could fail.
     if (mState.mSeparable)
     {
-        mState.mExecutable->saveLinkedStateInfo();
+        mState.mExecutable->saveLinkedStateInfo(mState);
         mLinkingState->linkedExecutable = mState.mExecutable;
     }
 
@@ -5551,4 +5551,17 @@ void Program::postResolveLink(const gl::Context *context)
     }
 }
 
+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

src/libANGLE/Program.h

@@ -822,6 +822,8 @@ class Program final : angle::NonCopyable, public LabeledObject
                                             int vertexShaderVersion,
                                             InfoLog &infoLog);
 
+    void fillProgramStateMap(ShaderMap<const ProgramState *> *programStatesOut);
+
   private:
     struct LinkingState;
 

src/libANGLE/ProgramExecutable.cpp

@@ -17,9 +17,7 @@ namespace gl
 {
 
 ProgramExecutable::ProgramExecutable()
-    : mProgramState(nullptr),
-      mProgramPipelineState(nullptr),
-      mMaxActiveAttribLocation(0),
+    : mMaxActiveAttribLocation(0),
       mAttributesTypeMask(0),
       mAttributesMask(0),
       mActiveSamplersMask(0),
@@ -48,9 +46,7 @@ ProgramExecutable::ProgramExecutable()
 }
 
 ProgramExecutable::ProgramExecutable(const ProgramExecutable &other)
-    : mProgramState(other.mProgramState),
-      mProgramPipelineState(other.mProgramPipelineState),
-      mLinkedGraphicsShaderStages(other.mLinkedGraphicsShaderStages),
+    : mLinkedGraphicsShaderStages(other.mLinkedGraphicsShaderStages),
       mLinkedComputeShaderStages(other.mLinkedComputeShaderStages),
       mActiveAttribLocationsMask(other.mActiveAttribLocationsMask),
       mMaxActiveAttribLocation(other.mMaxActiveAttribLocation),
@@ -185,22 +181,6 @@ void ProgramExecutable::save(gl::BinaryOutputStream *stream) const
     stream->writeInt(static_cast<bool>(mPipelineHasComputeTextures));
 }
 
-const ProgramState *ProgramExecutable::getProgramState(ShaderType shaderType) const
-{
-    if (mProgramState &&
-        (hasLinkedShaderStage(shaderType) || mProgramState->getAttachedShader(shaderType)))
-    {
-        return mProgramState;
-    }
-    else if (mProgramPipelineState && (hasLinkedShaderStage(shaderType) ||
-                                       mProgramPipelineState->getShaderProgram(shaderType)))
-    {
-        return &mProgramPipelineState->getShaderProgram(shaderType)->getState();
-    }
-
-    return nullptr;
-}
-
 int ProgramExecutable::getInfoLogLength() const
 {
     return static_cast<int>(mInfoLog.getLength());
@@ -385,7 +365,9 @@ void ProgramExecutable::setSamplerUniformTextureTypeAndFormat(
     mActiveSamplerFormats[textureUnitIndex] = foundFormat;
 }
 
-bool ProgramExecutable::linkValidateGlobalNames(InfoLog &infoLog) const
+bool ProgramExecutable::linkValidateGlobalNames(
+    InfoLog &infoLog,
+    const ShaderMap<const ProgramState *> &programStates) const
 {
     std::unordered_map<std::string, const sh::ShaderVariable *> uniformMap;
     using BlockAndFieldPair = std::pair<const sh::InterfaceBlock *, const sh::ShaderVariable *>;
@@ -393,7 +375,7 @@ bool ProgramExecutable::linkValidateGlobalNames(InfoLog &infoLog) const
 
     for (ShaderType shaderType : kAllGraphicsShaderTypes)
     {
-        const ProgramState *programState = getProgramState(shaderType);
+        const ProgramState *programState = programStates[shaderType];
         if (!programState)
         {
             continue;
@@ -473,7 +455,7 @@ bool ProgramExecutable::linkValidateGlobalNames(InfoLog &infoLog) const
     }
 
     // Validate no uniform names conflict with attribute names
-    const ProgramState *programState = getProgramState(ShaderType::Vertex);
+    const ProgramState *programState = programStates[ShaderType::Vertex];
     if (programState)
     {
         Shader *vertexShader = programState->getAttachedShader(ShaderType::Vertex);
@@ -510,14 +492,11 @@ void ProgramExecutable::updateCanDrawWith()
         (hasLinkedShaderStage(ShaderType::Vertex) && hasLinkedShaderStage(ShaderType::Fragment));
 }
 
-void ProgramExecutable::saveLinkedStateInfo()
+void ProgramExecutable::saveLinkedStateInfo(const ProgramState &state)
 {
-    // Only a Program's linked data needs to be saved, not a ProgramPipeline's
-    ASSERT(mProgramState);
-
     for (ShaderType shaderType : getLinkedShaderStages())
     {
-        Shader *shader = mProgramState->getAttachedShader(shaderType);
+        Shader *shader = state.getAttachedShader(shaderType);
         ASSERT(shader);
         mLinkedOutputVaryings[shaderType] = shader->getOutputVaryings();
         mLinkedInputVaryings[shaderType]  = shader->getInputVaryings();

src/libANGLE/ProgramExecutable.h

@@ -110,8 +110,6 @@ class ProgramExecutable
     void save(gl::BinaryOutputStream *stream) const;
     void load(gl::BinaryInputStream *stream);
 
-    const ProgramState *getProgramState(ShaderType shaderType) const;
-
     int getInfoLogLength() const;
     InfoLog &getInfoLog() { return mInfoLog; }
     void getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const;
@@ -202,19 +200,8 @@ class ProgramExecutable
     // Count the number of uniform and storage buffer declarations, counting arrays as one.
     size_t getTransformFeedbackBufferCount() const { return mTransformFeedbackStrides.size(); }
 
-    bool linkValidateGlobalNames(InfoLog &infoLog) const;
-
-    // TODO: http://anglebug.com/4520: Remove mProgramState/mProgramPipelineState
-    void setProgramState(ProgramState *state)
-    {
-        ASSERT(!mProgramState && !mProgramPipelineState);
-        mProgramState = state;
-    }
-    void setProgramPipelineState(ProgramPipelineState *state)
-    {
-        ASSERT(!mProgramState && !mProgramPipelineState);
-        mProgramPipelineState = state;
-    }
+    bool linkValidateGlobalNames(InfoLog &infoLog,
+                                 const ShaderMap<const ProgramState *> &programStates) const;
 
     void updateCanDrawWith();
     bool hasVertexAndFragmentShader() const { return mCanDrawWith; }
@@ -285,7 +272,7 @@ class ProgramExecutable
         return *mResources;
     }
 
-    void saveLinkedStateInfo();
+    void saveLinkedStateInfo(const ProgramState &state);
     std::vector<sh::ShaderVariable> getLinkedOutputVaryings(ShaderType shaderType)
     {
         return mLinkedOutputVaryings[shaderType];
@@ -310,10 +297,6 @@ class ProgramExecutable
     void setSamplerUniformTextureTypeAndFormat(size_t textureUnitIndex,
                                                std::vector<SamplerBinding> &samplerBindings);
 
-    // TODO: http://anglebug.com/4520: Remove mProgramState/mProgramPipelineState
-    ProgramState *mProgramState;
-    ProgramPipelineState *mProgramPipelineState;
-
     InfoLog mInfoLog;
 
     ShaderBitSet mLinkedGraphicsShaderStages;

src/libANGLE/ProgramPipeline.cpp

@@ -29,8 +29,6 @@ ProgramPipelineState::ProgramPipelineState()
       mHasBeenBound(false),
       mExecutable(new ProgramExecutable())
 {
-    mExecutable->setProgramPipelineState(this);
-
     for (const ShaderType shaderType : gl::AllShaderTypes())
     {
         mPrograms[shaderType] = nullptr;
@@ -471,7 +469,9 @@ angle::Result ProgramPipeline::link(const Context *context)
             return angle::Result::Stop;
         }
 
-        if (!mState.mExecutable->linkValidateGlobalNames(infoLog))
+        gl::ShaderMap<const gl::ProgramState *> programStates;
+        fillProgramStateMap(&programStates);
+        if (!mState.mExecutable->linkValidateGlobalNames(infoLog, programStates))
         {
             return angle::Result::Stop;
         }
@@ -620,4 +620,18 @@ angle::Result ProgramPipeline::syncState(const Context *context)
     return angle::Result::Continue;
 }
 
+void ProgramPipeline::fillProgramStateMap(ShaderMap<const ProgramState *> *programStatesOut)
+{
+    for (ShaderType shaderType : AllShaderTypes())
+    {
+        (*programStatesOut)[shaderType] = nullptr;
+
+        Program *program = getShaderProgram(shaderType);
+        if (program)
+        {
+            (*programStatesOut)[shaderType] = &program->getState();
+        }
+    }
+}
+
 }  // namespace gl

src/libANGLE/ProgramPipeline.h

@@ -148,6 +148,8 @@ class ProgramPipeline final : public RefCountObject<ProgramPipelineID>, public L
 
     void updateExecutableTextures();
 
+    void fillProgramStateMap(gl::ShaderMap<const gl::ProgramState *> *programStatesOut);
+
   private:
     void updateLinkedShaderStages();
     void updateExecutableAttributes();