Rename ProgramState::getProgramExecutable() to getExecutable()

src/libANGLE/Program.h

@@ -308,12 +308,12 @@ class ProgramState final : angle::NonCopyable
         return mUniformLocationBindings;
     }
 
-    const ProgramExecutable &getProgramExecutable() const
+    const ProgramExecutable &getExecutable() const
     {
         ASSERT(mExecutable);
         return *mExecutable;
     }
-    ProgramExecutable &getProgramExecutable()
+    ProgramExecutable &getExecutable()
     {
         ASSERT(mExecutable);
         return *mExecutable;
@@ -809,8 +809,8 @@ class Program final : angle::NonCopyable, public LabeledObject
 
     rx::Serial serial() const { return mSerial; }
 
-    const ProgramExecutable &getExecutable() const { return mState.getProgramExecutable(); }
-    ProgramExecutable &getExecutable() { return mState.getProgramExecutable(); }
+    const ProgramExecutable &getExecutable() const { return mState.getExecutable(); }
+    ProgramExecutable &getExecutable() { return mState.getExecutable(); }
 
     const char *validateDrawStates(const State &state, const gl::Extensions &extensions) const;
 

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -1307,7 +1307,7 @@ angle::Result ProgramD3D::loadBinaryShaderExecutables(d3d::Context *contextD3D,
             stream->readInt<unsigned int>(), gl::TextureType::_2D));
     }
 
-    initializeUniformStorage(mState.getProgramExecutable().getLinkedShaderStages());
+    initializeUniformStorage(mState.getExecutable().getLinkedShaderStages());
 
     dirtyAllUniforms();
 
@@ -2353,7 +2353,7 @@ const std::vector<D3DUBOCacheUseSB> &ProgramD3D::getShaderUniformBufferCacheUseS
 
 void ProgramD3D::dirtyAllUniforms()
 {
-    mShaderUniformsDirty = mState.getProgramExecutable().getLinkedShaderStages();
+    mShaderUniformsDirty = mState.getExecutable().getLinkedShaderStages();
 }
 
 void ProgramD3D::markUniformsClean()
@@ -3049,7 +3049,7 @@ void ProgramD3D::updateCachedInputLayout(Serial associatedSerial, const gl::Stat
 
     const auto &vertexAttributes = state.getVertexArray()->getVertexAttributes();
     const gl::AttributesMask &attributesMask =
-        mState.getProgramExecutable().getActiveAttribLocationsMask();
+        mState.getExecutable().getActiveAttribLocationsMask();
 
     for (size_t locationIndex : attributesMask)
     {

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -339,7 +339,7 @@ class ProgramD3D : public ProgramImpl
 
     bool hasShaderStage(gl::ShaderType shaderType) const
     {
-        return mState.getProgramExecutable().getLinkedShaderStages()[shaderType];
+        return mState.getExecutable().getLinkedShaderStages()[shaderType];
     }
 
     void assignImage2DRegisters(unsigned int startImageIndex,

src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp

@@ -194,7 +194,7 @@ void SortAttributesByLayout(const ProgramD3D &programD3D,
     sortedAttributesOut->clear();
 
     const AttribIndexArray &locationToSemantic = programD3D.getAttribLocationToD3DSemantics();
-    const gl::ProgramExecutable &executable    = programD3D.getState().getProgramExecutable();
+    const gl::ProgramExecutable &executable    = programD3D.getState().getExecutable();
 
     for (auto locationIndex : executable.getActiveAttribLocationsMask())
     {
@@ -2047,7 +2047,7 @@ angle::Result StateManager11::syncCurrentValueAttribs(
     const gl::Context *context,
     const std::vector<gl::VertexAttribCurrentValueData> &currentValues)
 {
-    const gl::ProgramExecutable &executable = mProgramD3D->getState().getProgramExecutable();
+    const gl::ProgramExecutable &executable = mProgramD3D->getState().getExecutable();
     const auto &activeAttribsMask           = executable.getActiveAttribLocationsMask();
     const auto &dirtyActiveAttribs          = (activeAttribsMask & mDirtyCurrentValueAttribs);
 

src/libANGLE/renderer/gl/ProgramGL.cpp

@@ -228,7 +228,7 @@ std::unique_ptr<LinkEvent> ProgramGL::link(const gl::Context *context,
         for (const auto &tfVarying : mState.getTransformFeedbackVaryingNames())
         {
             gl::ShaderType tfShaderType =
-                mState.getProgramExecutable().hasLinkedShaderStage(gl::ShaderType::Geometry)
+                mState.getExecutable().hasLinkedShaderStage(gl::ShaderType::Geometry)
                     ? gl::ShaderType::Geometry
                     : gl::ShaderType::Vertex;
             std::string tfVaryingMappedName =

src/libANGLE/renderer/glslang_wrapper_utils.cpp

@@ -1927,10 +1927,9 @@ void GlslangGetShaderSource(GlslangSourceOptions &options,
         }
     }
 
-    for (const gl::ShaderType shaderType :
-         programState.getProgramExecutable().getLinkedShaderStages())
+    for (const gl::ShaderType shaderType : programState.getExecutable().getLinkedShaderStages())
     {
-        GlslangAssignLocations(options, programState.getProgramExecutable(), shaderType,
+        GlslangAssignLocations(options, programState.getExecutable(), shaderType,
                                programInterfaceInfo, variableInfoMapOut);
     }
 }

src/libANGLE/renderer/metal/ProgramMtl.mm

@@ -318,7 +318,7 @@ angle::Result ProgramMtl::linkImpl(const gl::Context *glContext,
     // Convert GLSL to spirv code
     gl::ShaderMap<std::vector<uint32_t>> shaderCodes;
     ANGLE_TRY(mtl::GlslangGetShaderSpirvCode(
-        contextMtl, mState.getProgramExecutable().getLinkedShaderStages(), contextMtl->getCaps(),
+        contextMtl, mState.getExecutable().getLinkedShaderStages(), contextMtl->getCaps(),
         shaderSources, variableInfoMap, &shaderCodes));
 
     // Convert spirv code to MSL

src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp

@@ -271,7 +271,7 @@ ProgramVk *ProgramExecutableVk::getShaderProgram(const gl::State &glState,
 {
     if (mProgram)
     {
-        const gl::ProgramExecutable &glExecutable = mProgram->getState().getProgramExecutable();
+        const gl::ProgramExecutable &glExecutable = mProgram->getState().getExecutable();
         if (glExecutable.hasLinkedShaderStage(shaderType))
         {
             return mProgram;
@@ -307,7 +307,7 @@ const gl::ProgramExecutable &ProgramExecutableVk::getGlExecutable()
     ASSERT(mProgram || mProgramPipeline);
     if (mProgram)
     {
-        return mProgram->getState().getProgramExecutable();
+        return mProgram->getState().getExecutable();
     }
     return mProgramPipeline->getState().getProgramExecutable();
 }
@@ -437,8 +437,7 @@ void ProgramExecutableVk::addImageDescriptorSetDesc(const gl::ProgramState &prog
         // The front-end always binds array image units sequentially.
         uint32_t arraySize = static_cast<uint32_t>(imageBinding.boundImageUnits.size());
 
-        for (const gl::ShaderType shaderType :
-             programState.getProgramExecutable().getLinkedShaderStages())
+        for (const gl::ShaderType shaderType : programState.getExecutable().getLinkedShaderStages())
         {
             if (!imageUniform.isActive(shaderType))
             {
@@ -492,8 +491,7 @@ void ProgramExecutableVk::addTextureDescriptorSetDesc(const gl::ProgramState &pr
             }
         }
 
-        for (const gl::ShaderType shaderType :
-             programState.getProgramExecutable().getLinkedShaderStages())
+        for (const gl::ShaderType shaderType : programState.getExecutable().getLinkedShaderStages())
         {
             if (!samplerUniform.isActive(shaderType))
             {
@@ -1187,7 +1185,7 @@ angle::Result ProgramExecutableVk::updateTransformFeedbackDescriptorSet(
     gl::ShaderMap<DefaultUniformBlock> &defaultUniformBlocks,
     ContextVk *contextVk)
 {
-    const gl::ProgramExecutable &executable = programState.getProgramExecutable();
+    const gl::ProgramExecutable &executable = programState.getExecutable();
     ASSERT(executable.hasTransformFeedbackOutput());
 
     ANGLE_TRY(allocateDescriptorSet(contextVk, kUniformsAndXfbDescriptorSetIndex));
@@ -1209,7 +1207,7 @@ void ProgramExecutableVk::updateTransformFeedbackDescriptorSetImpl(
 {
     const gl::State &glState                 = contextVk->getState();
     gl::TransformFeedback *transformFeedback = glState.getCurrentTransformFeedback();
-    const gl::ProgramExecutable &executable  = programState.getProgramExecutable();
+    const gl::ProgramExecutable &executable  = programState.getExecutable();
 
     if (!executable.hasTransformFeedbackOutput())
     {

src/libANGLE/renderer/vulkan/ProgramPipelineVk.cpp

@@ -80,8 +80,8 @@ angle::Result ProgramPipelineVk::link(const gl::Context *glContext)
             glslangProgramInterfaceInfo.locationsUsedForXfbExtension =
                 programProgramInterfaceInfo.locationsUsedForXfbExtension;
 
-            GlslangAssignLocations(options, glProgram->getState().getProgramExecutable(),
-                                   shaderType, &glslangProgramInterfaceInfo,
+            GlslangAssignLocations(options, glProgram->getState().getExecutable(), shaderType,
+                                   &glslangProgramInterfaceInfo,
                                    &mExecutable.getShaderInterfaceVariableInfoMap());
         }
     }

src/libANGLE/renderer/vulkan/ProgramVk.cpp

@@ -275,7 +275,7 @@ void ProgramVk::fillProgramStateMap(gl::ShaderMap<const gl::ProgramState *> *pro
     for (gl::ShaderType shaderType : gl::AllShaderTypes())
     {
         (*programStatesOut)[shaderType] = nullptr;
-        if (mState.getProgramExecutable().hasLinkedShaderStage(shaderType))
+        if (mState.getExecutable().hasLinkedShaderStage(shaderType))
         {
             (*programStatesOut)[shaderType] = &mState;
         }
@@ -302,7 +302,7 @@ std::unique_ptr<LinkEvent> ProgramVk::link(const gl::Context *context,
 
     // Compile the shaders.
     angle::Result status =
-        mShaderInfo.initShaders(contextVk, mState.getProgramExecutable().getLinkedShaderStages(),
+        mShaderInfo.initShaders(contextVk, mState.getExecutable().getLinkedShaderStages(),
                                 shaderSources, mExecutable.mVariableInfoMap);
     if (status != angle::Result::Continue)
     {
@@ -348,7 +348,7 @@ angle::Result ProgramVk::initDefaultUniformBlocks(const gl::Context *glContext)
 void ProgramVk::generateUniformLayoutMapping(gl::ShaderMap<sh::BlockLayoutMap> &layoutMap,
                                              gl::ShaderMap<size_t> &requiredBufferSize)
 {
-    const gl::ProgramExecutable &glExecutable = mState.getProgramExecutable();
+    const gl::ProgramExecutable &glExecutable = mState.getExecutable();
 
     for (const gl::ShaderType shaderType : glExecutable.getLinkedShaderStages())
     {
@@ -367,7 +367,7 @@ void ProgramVk::initDefaultUniformLayoutMapping(gl::ShaderMap<sh::BlockLayoutMap
 {
     // Init the default block layout info.
     const auto &uniforms                      = mState.getUniforms();
-    const gl::ProgramExecutable &glExecutable = mState.getProgramExecutable();
+    const gl::ProgramExecutable &glExecutable = mState.getExecutable();
 
     for (const gl::VariableLocation &location : mState.getUniformLocations())
     {
@@ -413,7 +413,7 @@ angle::Result ProgramVk::resizeUniformBlockMemory(ContextVk *contextVk,
                                                   gl::ShaderMap<size_t> &requiredBufferSize)
 {
     RendererVk *renderer                      = contextVk->getRenderer();
-    const gl::ProgramExecutable &glExecutable = mState.getProgramExecutable();
+    const gl::ProgramExecutable &glExecutable = mState.getExecutable();
 
     for (const gl::ShaderType shaderType : glExecutable.getLinkedShaderStages())
     {
@@ -451,7 +451,7 @@ void ProgramVk::setUniformImpl(GLint location, GLsizei count, const T *v, GLenum
 {
     const gl::VariableLocation &locationInfo  = mState.getUniformLocations()[location];
     const gl::LinkedUniform &linkedUniform    = mState.getUniforms()[locationInfo.index];
-    const gl::ProgramExecutable &glExecutable = mState.getProgramExecutable();
+    const gl::ProgramExecutable &glExecutable = mState.getExecutable();
 
     ASSERT(!linkedUniform.isSampler());
 
@@ -618,7 +618,7 @@ void ProgramVk::setUniformMatrixfv(GLint location,
 {
     const gl::VariableLocation &locationInfo  = mState.getUniformLocations()[location];
     const gl::LinkedUniform &linkedUniform    = mState.getUniforms()[locationInfo.index];
-    const gl::ProgramExecutable &glExecutable = mState.getProgramExecutable();
+    const gl::ProgramExecutable &glExecutable = mState.getExecutable();
 
     for (const gl::ShaderType shaderType : glExecutable.getLinkedShaderStages())
     {
@@ -756,7 +756,7 @@ angle::Result ProgramVk::updateUniforms(ContextVk *contextVk)
 
     bool anyNewBufferAllocated                = false;
     uint32_t offsetIndex                      = 0;
-    const gl::ProgramExecutable &glExecutable = mState.getProgramExecutable();
+    const gl::ProgramExecutable &glExecutable = mState.getExecutable();
 
     // Update buffer memory by immediate mapping. This immediate update only works once.
     for (const gl::ShaderType shaderType : glExecutable.getLinkedShaderStages())