Revert "Merge the ProgramBinary class into Program."

src/libANGLE/Context.cpp

@@ -18,6 +18,7 @@
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/Renderbuffer.h"
 #include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/Query.h"
 #include "libANGLE/ResourceManager.h"
 #include "libANGLE/Sampler.h"
@@ -122,6 +123,18 @@ Context::Context(int clientVersion, const Context *shareContext, rx::Renderer *r
 
 Context::~Context()
 {
+    GLuint currentProgram = mState.getCurrentProgramId();
+    if (currentProgram != 0)
+    {
+        Program *programObject = mResourceManager->getProgram(currentProgram);
+        if (programObject)
+        {
+            programObject->release();
+        }
+        currentProgram = 0;
+    }
+    mState.setCurrentProgram(0, NULL);
+
     while (!mFramebufferMap.empty())
     {
         deleteFramebuffer(mFramebufferMap.begin()->first);
@@ -610,7 +623,58 @@ void Context::bindPixelUnpackBuffer(GLuint buffer)
 
 void Context::useProgram(GLuint program)
 {
-    mState.setProgram(getProgram(program));
+    GLuint priorProgramId = mState.getCurrentProgramId();
+    Program *priorProgram = mResourceManager->getProgram(priorProgramId);
+
+    if (priorProgramId != program)
+    {
+        mState.setCurrentProgram(program, mResourceManager->getProgram(program));
+
+        if (priorProgram)
+        {
+            priorProgram->release();
+        }
+    }
+}
+
+Error Context::linkProgram(GLuint program)
+{
+    Program *programObject = mResourceManager->getProgram(program);
+
+    Error error = programObject->link(getData());
+    if (error.isError())
+    {
+        return error;
+    }
+
+    // if the current program was relinked successfully we
+    // need to install the new executables
+    if (programObject->isLinked() && program == mState.getCurrentProgramId())
+    {
+        mState.setCurrentProgramBinary(programObject->getProgramBinary());
+    }
+
+    return Error(GL_NO_ERROR);
+}
+
+Error Context::setProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLint length)
+{
+    Program *programObject = mResourceManager->getProgram(program);
+
+    Error error = programObject->setProgramBinary(binaryFormat, binary, length);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    // if the current program was reloaded successfully we
+    // need to install the new executables
+    if (programObject->isLinked() && program == mState.getCurrentProgramId())
+    {
+        mState.setCurrentProgramBinary(programObject->getProgramBinary());
+    }
+
+    return Error(GL_NO_ERROR);
 }
 
 void Context::bindTransformFeedback(GLuint transformFeedback)

src/libANGLE/Context.h

@@ -43,6 +43,7 @@ namespace gl
 {
 class Shader;
 class Program;
+class ProgramBinary;
 class Texture;
 class Texture2D;
 class TextureCubeMap;
@@ -125,6 +126,8 @@ class ANGLE_EXPORT Context
     void bindPixelPackBuffer(GLuint buffer);
     void bindPixelUnpackBuffer(GLuint buffer);
     void useProgram(GLuint program);
+    Error linkProgram(GLuint program);
+    Error setProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLint length);
     void bindTransformFeedback(GLuint transformFeedback);
 
     Error beginQuery(GLenum target, GLuint query);

src/libANGLE/ProgramBinary.h

+//
+// Copyright (c) 2002-2014 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.h: Defines the gl::Program class. Implements GL program objects
+// and related functionality. [OpenGL ES 2.0.24] section 2.10.3 page 28.
+
+#ifndef LIBANGLE_PROGRAM_BINARY_H_
+#define LIBANGLE_PROGRAM_BINARY_H_
+
+#include "common/mathutil.h"
+#include "libANGLE/angletypes.h"
+#include "libANGLE/RefCountObject.h"
+#include "libANGLE/Uniform.h"
+#include "libANGLE/Shader.h"
+#include "libANGLE/Constants.h"
+#include "libANGLE/renderer/d3d/VertexDataManager.h"
+#include "libANGLE/renderer/d3d/DynamicHLSL.h"
+#include "libANGLE/export.h"
+
+#include "angle_gl.h"
+
+#include <string>
+#include <vector>
+
+namespace sh
+{
+class HLSLBlockEncoder;
+}
+
+#include <GLES3/gl3.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include <string>
+#include <vector>
+
+namespace rx
+{
+class ShaderExecutable;
+struct TranslatedAttribute;
+class UniformStorage;
+class ProgramImpl;
+}
+
+namespace gl
+{
+struct Caps;
+class Shader;
+class InfoLog;
+class AttributeBindings;
+class Buffer;
+class Framebuffer;
+struct Data;
+
+// Struct used for correlating uniforms/elements of uniform arrays to handles
+struct VariableLocation
+{
+    VariableLocation()
+    {
+    }
+
+    VariableLocation(const std::string &name, unsigned int element, unsigned int index);
+
+    std::string name;
+    unsigned int element;
+    unsigned int index;
+};
+
+struct LinkedVarying
+{
+    LinkedVarying();
+    LinkedVarying(const std::string &name, GLenum type, GLsizei size, const std::string &semanticName,
+                  unsigned int semanticIndex, unsigned int semanticIndexCount);
+
+    // Original GL name
+    std::string name;
+
+    GLenum type;
+    GLsizei size;
+
+    // DirectX semantic information
+    std::string semanticName;
+    unsigned int semanticIndex;
+    unsigned int semanticIndexCount;
+};
+
+struct LinkResult
+{
+    bool linkSuccess;
+    Error error;
+
+    LinkResult(bool linkSuccess, const Error &error);
+};
+
+// This is the result of linking a program. It is the state that would be passed to ProgramBinary.
+class ANGLE_EXPORT ProgramBinary : public RefCountObject
+{
+  public:
+    explicit ProgramBinary(rx::ProgramImpl *impl);
+    ~ProgramBinary();
+
+    rx::ProgramImpl *getImplementation() { return mProgram; }
+    const rx::ProgramImpl *getImplementation() const { return mProgram; }
+
+    GLuint getAttributeLocation(const char *name);
+    int getSemanticIndex(int attributeIndex);
+
+    GLint getSamplerMapping(SamplerType type, unsigned int samplerIndex, const Caps &caps);
+    GLenum getSamplerTextureType(SamplerType type, unsigned int samplerIndex);
+    GLint getUsedSamplerRange(SamplerType type);
+    bool usesPointSize() const;
+
+    GLint getUniformLocation(std::string name);
+    GLuint getUniformIndex(std::string name);
+    GLuint getUniformBlockIndex(std::string name);
+    void setUniform1fv(GLint location, GLsizei count, const GLfloat *v);
+    void setUniform2fv(GLint location, GLsizei count, const GLfloat *v);
+    void setUniform3fv(GLint location, GLsizei count, const GLfloat *v);
+    void setUniform4fv(GLint location, GLsizei count, const GLfloat *v);
+    void setUniform1iv(GLint location, GLsizei count, const GLint *v);
+    void setUniform2iv(GLint location, GLsizei count, const GLint *v);
+    void setUniform3iv(GLint location, GLsizei count, const GLint *v);
+    void setUniform4iv(GLint location, GLsizei count, const GLint *v);
+    void setUniform1uiv(GLint location, GLsizei count, const GLuint *v);
+    void setUniform2uiv(GLint location, GLsizei count, const GLuint *v);
+    void setUniform3uiv(GLint location, GLsizei count, const GLuint *v);
+    void setUniform4uiv(GLint location, GLsizei count, const GLuint *v);
+    void setUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    void setUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    void setUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    void setUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    void setUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    void setUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    void setUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    void setUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    void setUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+
+    void getUniformfv(GLint location, GLfloat *params);
+    void getUniformiv(GLint location, GLint *params);
+    void getUniformuiv(GLint location, GLuint *params);
+
+    Error applyUniforms();
+    Error applyUniformBuffers(const std::vector<Buffer*> boundBuffers, const Caps &caps);
+
+    LinkResult load(InfoLog &infoLog, GLenum binaryFormat, const void *binary, GLsizei length);
+    Error save(GLenum *binaryFormat, void *binary, GLsizei bufSize, GLsizei *length);
+    GLint getLength();
+
+    LinkResult link(const Data &data, InfoLog &infoLog, const AttributeBindings &attributeBindings,
+                    Shader *fragmentShader, Shader *vertexShader,
+                    const std::vector<std::string> &transformFeedbackVaryings,
+                    GLenum transformFeedbackBufferMode);
+
+    void getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) const;
+    GLint getActiveAttributeCount() const;
+    GLint getActiveAttributeMaxLength() const;
+
+    void getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) const;
+    GLint getActiveUniformCount() const;
+    GLint getActiveUniformMaxLength() const;
+    GLint getActiveUniformi(GLuint index, GLenum pname) const;
+    bool isValidUniformLocation(GLint location) const;
+    LinkedUniform *getUniformByLocation(GLint location) const;
+    LinkedUniform *getUniformByName(const std::string &name) const;
+
+    void getActiveUniformBlockName(GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) const;
+    void getActiveUniformBlockiv(GLuint uniformBlockIndex, GLenum pname, GLint *params) const;
+    GLuint getActiveUniformBlockCount() const;
+    GLuint getActiveUniformBlockMaxLength() const;
+    UniformBlock *getUniformBlockByIndex(GLuint blockIndex);
+
+    GLint getFragDataLocation(const char *name) const;
+
+    size_t getTransformFeedbackVaryingCount() const;
+    const LinkedVarying &getTransformFeedbackVarying(size_t idx) const;
+    GLenum getTransformFeedbackBufferMode() const;
+
+    void validate(InfoLog &infoLog, const Caps &caps);
+    bool validateSamplers(InfoLog *infoLog, const Caps &caps);
+    bool isValidated() const;
+    void updateSamplerMapping();
+
+    unsigned int getSerial() const;
+
+    void initAttributesByLayout();
+    void sortAttributesByLayout(rx::TranslatedAttribute attributes[MAX_VERTEX_ATTRIBS], int sortedSemanticIndices[MAX_VERTEX_ATTRIBS]) const;
+
+    static bool linkVaryings(InfoLog &infoLog, Shader *fragmentShader, Shader *vertexShader);
+    static bool linkValidateUniforms(InfoLog &infoLog, const std::string &uniformName, const sh::Uniform &vertexUniform, const sh::Uniform &fragmentUniform);
+    static bool linkValidateInterfaceBlockFields(InfoLog &infoLog, const std::string &uniformName, const sh::InterfaceBlockField &vertexUniform, const sh::InterfaceBlockField &fragmentUniform);
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(ProgramBinary);
+
+    void reset();
+
+    bool linkAttributes(InfoLog &infoLog, const AttributeBindings &attributeBindings, const Shader *vertexShader);
+    bool linkUniformBlocks(InfoLog &infoLog, const Shader &vertexShader, const Shader &fragmentShader, const Caps &caps);
+    bool areMatchingInterfaceBlocks(gl::InfoLog &infoLog, const sh::InterfaceBlock &vertexInterfaceBlock,
+                                    const sh::InterfaceBlock &fragmentInterfaceBlock);
+
+    static bool linkValidateVariablesBase(InfoLog &infoLog,
+                                          const std::string &variableName,
+                                          const sh::ShaderVariable &vertexVariable,
+                                          const sh::ShaderVariable &fragmentVariable,
+                                          bool validatePrecision);
+
+    static bool linkValidateVaryings(InfoLog &infoLog, const std::string &varyingName, const sh::Varying &vertexVarying, const sh::Varying &fragmentVarying);
+    bool gatherTransformFeedbackLinkedVaryings(InfoLog &infoLog, const std::vector<LinkedVarying> &linkedVaryings,
+                                               const std::vector<std::string> &transformFeedbackVaryingNames,
+                                               GLenum transformFeedbackBufferMode,
+                                               std::vector<LinkedVarying> *outTransformFeedbackLinkedVaryings,
+                                               const Caps &caps) const;
+    bool assignUniformBlockRegister(InfoLog &infoLog, UniformBlock *uniformBlock, GLenum shader, unsigned int registerIndex, const Caps &caps);
+    void defineOutputVariables(Shader *fragmentShader);
+
+    rx::ProgramImpl *mProgram;
+
+    sh::Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS];
+    int mSemanticIndex[MAX_VERTEX_ATTRIBS];
+    int mAttributesByLayout[MAX_VERTEX_ATTRIBS];
+
+    std::map<int, VariableLocation> mOutputVariables;
+
+    bool mValidated;
+
+    const unsigned int mSerial;
+
+    static unsigned int issueSerial();
+    static unsigned int mCurrentSerial;
+};
+
+}
+
+#endif   // LIBANGLE_PROGRAM_BINARY_H_

src/libANGLE/ResourceManager.cpp

@@ -106,7 +106,7 @@ GLuint ResourceManager::createProgram()
 {
     GLuint handle = mProgramShaderHandleAllocator.allocate();
 
-    mProgramMap[handle] = new Program(mRenderer->createProgram(), this, handle);
+    mProgramMap[handle] = new Program(mRenderer, this, handle);
 
     return handle;
 }

src/libANGLE/State.cpp

@@ -138,7 +138,8 @@ void State::initialize(const Caps& caps, GLuint clientVersion)
     mActiveQueries[GL_ANY_SAMPLES_PASSED_CONSERVATIVE].set(NULL);
     mActiveQueries[GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN].set(NULL);
 
-    mProgram = NULL;
+    mCurrentProgramId = 0;
+    mCurrentProgramBinary.set(NULL);
 
     mReadFramebuffer = NULL;
     mDrawFramebuffer = NULL;
@@ -162,12 +163,6 @@ void State::reset()
     mArrayBuffer.set(NULL);
     mRenderbuffer.set(NULL);
 
-    if (mProgram)
-    {
-        mProgram->release();
-    }
-    mProgram = NULL;
-
     mTransformFeedback.set(NULL);
 
     for (State::ActiveQueryMap::iterator i = mActiveQueries.begin(); i != mActiveQueries.end(); i++)
@@ -192,8 +187,6 @@ void State::reset()
 
     mPack.pixelBuffer.set(NULL);
     mUnpack.pixelBuffer.set(NULL);
-
-    mProgram = NULL;
 }
 
 const RasterizerState &State::getRasterizerState() const
@@ -852,27 +845,31 @@ bool State::removeVertexArrayBinding(GLuint vertexArray)
     return false;
 }
 
-void State::setProgram(Program *newProgram)
+void State::setCurrentProgram(GLuint programId, Program *newProgram)
 {
-    if (mProgram != newProgram)
+    mCurrentProgramId = programId; // set new ID before trying to delete program binary; otherwise it will only be flagged for deletion
+    mCurrentProgramBinary.set(NULL);
+
+    if (newProgram)
     {
-        if (mProgram)
-        {
-            mProgram->release();
-        }
+        newProgram->addRef();
+        mCurrentProgramBinary.set(newProgram->getProgramBinary());
+    }
+}
 
-        mProgram = newProgram;
+void State::setCurrentProgramBinary(ProgramBinary *binary)
+{
+    mCurrentProgramBinary.set(binary);
+}
 
-        if (mProgram)
-        {
-            newProgram->addRef();
-        }
-    }
+GLuint State::getCurrentProgramId() const
+{
+    return mCurrentProgramId;
 }
 
-Program *State::getProgram() const
+ProgramBinary *State::getCurrentProgramBinary() const
 {
-    return mProgram;
+    return mCurrentProgramBinary.get();
 }
 
 void State::setTransformFeedbackBinding(TransformFeedback *transformFeedback)
@@ -1217,7 +1214,7 @@ void State::getIntegerv(const gl::Data &data, GLenum pname, GLint *params)
       case GL_READ_FRAMEBUFFER_BINDING_ANGLE:           *params = mReadFramebuffer->id();                         break;
       case GL_RENDERBUFFER_BINDING:                     *params = mRenderbuffer.id();                             break;
       case GL_VERTEX_ARRAY_BINDING:                     *params = mVertexArray->id();                             break;
-      case GL_CURRENT_PROGRAM:                          *params = mProgram ? mProgram->id() : 0;                  break;
+      case GL_CURRENT_PROGRAM:                          *params = mCurrentProgramId;                              break;
       case GL_PACK_ALIGNMENT:                           *params = mPack.alignment;                                break;
       case GL_PACK_REVERSE_ROW_ORDER_ANGLE:             *params = mPack.reverseRowOrder;                          break;
       case GL_UNPACK_ALIGNMENT:                         *params = mUnpack.alignment;                              break;

src/libANGLE/State.h

@@ -168,8 +168,10 @@ class ANGLE_EXPORT State
     bool removeVertexArrayBinding(GLuint vertexArray);
 
     // Program binding manipulation
-    void setProgram(Program *newProgram);
-    Program *getProgram() const;
+    void setCurrentProgram(GLuint programId, Program *newProgram);
+    void setCurrentProgramBinary(ProgramBinary *binary);
+    GLuint getCurrentProgramId() const;
+    ProgramBinary *getCurrentProgramBinary() const;
 
     // Transform feedback object (not buffer) binding manipulation
     void setTransformFeedbackBinding(TransformFeedback *transformFeedback);
@@ -283,7 +285,8 @@ class ANGLE_EXPORT State
     Framebuffer *mReadFramebuffer;
     Framebuffer *mDrawFramebuffer;
     BindingPointer<Renderbuffer> mRenderbuffer;
-    Program *mProgram;
+    GLuint mCurrentProgramId;
+    BindingPointer<ProgramBinary> mCurrentProgramBinary;
 
     typedef std::vector<VertexAttribCurrentValueData> VertexAttribVector;
     VertexAttribVector mVertexAttribCurrentValues; // From glVertexAttrib

src/libANGLE/angletypes.cpp

@@ -7,7 +7,7 @@
 // angletypes.h : Defines a variety of structures and enum types that are used throughout libGLESv2
 
 #include "libANGLE/angletypes.h"
-#include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/VertexAttribute.h"
 #include "libANGLE/State.h"
 #include "libANGLE/VertexArray.h"
@@ -149,13 +149,13 @@ VertexFormat::VertexFormat(const VertexAttribute &attrib, GLenum currentValueTyp
 }
 
 void VertexFormat::GetInputLayout(VertexFormat *inputLayout,
-                                  Program *program,
+                                  ProgramBinary *programBinary,
                                   const State &state)
 {
     const VertexAttribute *vertexAttributes = state.getVertexArray()->getVertexAttributes();
     for (unsigned int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
     {
-        int semanticIndex = program->getSemanticIndex(attributeIndex);
+        int semanticIndex = programBinary->getSemanticIndex(attributeIndex);
 
         if (semanticIndex != -1)
         {

src/libANGLE/angletypes.h

@@ -18,7 +18,7 @@ namespace gl
 {
 class Buffer;
 class State;
-class Program;
+class ProgramBinary;
 struct VertexAttribute;
 struct VertexAttribCurrentValueData;
 
@@ -233,7 +233,7 @@ struct VertexFormat
     VertexFormat(const VertexAttribute &attribute, GLenum currentValueType);
 
     static void GetInputLayout(VertexFormat *inputLayout,
-                               Program *program,
+                               ProgramBinary *programBinary,
                                const State& currentValues);
 
     bool operator==(const VertexFormat &other) const;

src/libANGLE/renderer/ProgramImpl.cpp

@@ -34,12 +34,6 @@ unsigned int ParseAndStripArrayIndex(std::string* name)
 
 }
 
-LinkResult::LinkResult(bool linkSuccess, const gl::Error &error)
-    : linkSuccess(linkSuccess),
-      error(error)
-{
-}
-
 ProgramImpl::~ProgramImpl()
 {
     // Ensure that reset was called by the inherited class during destruction

src/libANGLE/renderer/ProgramImpl.h

@@ -12,7 +12,7 @@
 #include "common/angleutils.h"
 #include "libANGLE/BinaryStream.h"
 #include "libANGLE/Constants.h"
-#include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/Shader.h"
 #include "libANGLE/renderer/Renderer.h"
 
@@ -21,13 +21,6 @@
 namespace rx
 {
 
-struct LinkResult
-{
-    bool linkSuccess;
-    gl::Error error;
-    LinkResult(bool linkSuccess, const gl::Error &error);
-};
-
 class ProgramImpl
 {
   public:
@@ -59,15 +52,15 @@ class ProgramImpl
     virtual GLenum getTransformFeedbackBufferMode() const = 0;
 
     virtual GLenum getBinaryFormat() = 0;
-    virtual LinkResult load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream) = 0;
+    virtual gl::LinkResult load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream) = 0;
     virtual gl::Error save(gl::BinaryOutputStream *stream) = 0;
 
-    virtual LinkResult link(const gl::Data &data, gl::InfoLog &infoLog,
-                            gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                            const std::vector<std::string> &transformFeedbackVaryings,
-                            GLenum transformFeedbackBufferMode,
-                            int *registers, std::vector<gl::LinkedVarying> *linkedVaryings,
-                            std::map<int, gl::VariableLocation> *outputVariables) = 0;
+    virtual gl::LinkResult link(const gl::Data &data, gl::InfoLog &infoLog,
+                                gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                const std::vector<std::string> &transformFeedbackVaryings,
+                                GLenum transformFeedbackBufferMode,
+                                int *registers, std::vector<gl::LinkedVarying> *linkedVaryings,
+                                std::map<int, gl::VariableLocation> *outputVariables) = 0;
 
     virtual void setUniform1fv(GLint location, GLsizei count, const GLfloat *v) = 0;
     virtual void setUniform2fv(GLint location, GLsizei count, const GLfloat *v) = 0;
@@ -105,8 +98,8 @@ class ProgramImpl
     virtual void updateSamplerMapping() = 0;
     virtual bool validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps) = 0;
 
-    virtual LinkResult compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                                                 int registers) = 0;
+    virtual gl::LinkResult compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                                     int registers) = 0;
 
     virtual bool linkUniforms(gl::InfoLog &infoLog, const gl::Shader &vertexShader, const gl::Shader &fragmentShader,
                               const gl::Caps &caps) = 0;

src/libANGLE/renderer/d3d/DynamicHLSL.cpp

@@ -10,6 +10,7 @@
 #include "libANGLE/renderer/d3d/ShaderD3D.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/Shader.h"
 #include "libANGLE/formatutils.h"
 

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -11,7 +11,6 @@
 
 #include "libANGLE/renderer/ProgramImpl.h"
 #include "libANGLE/renderer/Workarounds.h"
-#include "libANGLE/renderer/d3d/DynamicHLSL.h"
 
 #include <string>
 #include <vector>
@@ -27,7 +26,6 @@ namespace rx
 {
 class RendererD3D;
 class UniformStorage;
-class ShaderExecutable;
 
 class ProgramD3D : public ProgramImpl
 {
@@ -53,7 +51,7 @@ class ProgramD3D : public ProgramImpl
     bool usesGeometryShader() const;
 
     GLenum getBinaryFormat() { return GL_PROGRAM_BINARY_ANGLE; }
-    LinkResult load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream);
+    gl::LinkResult load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream);
     gl::Error save(gl::BinaryOutputStream *stream);
 
     gl::Error getPixelExecutableForFramebuffer(const gl::Framebuffer *fbo, ShaderExecutable **outExectuable);
@@ -61,15 +59,15 @@ class ProgramD3D : public ProgramImpl
     gl::Error getVertexExecutableForInputLayout(const gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS], ShaderExecutable **outExectuable);
     ShaderExecutable *getGeometryExecutable() const { return mGeometryExecutable; }
 
-    LinkResult compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                                         int registers);
+    gl::LinkResult compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                             int registers);
 
-    LinkResult link(const gl::Data &data, gl::InfoLog &infoLog,
-                    gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                    const std::vector<std::string> &transformFeedbackVaryings,
-                    GLenum transformFeedbackBufferMode,
-                    int *registers, std::vector<gl::LinkedVarying> *linkedVaryings,
-                    std::map<int, gl::VariableLocation> *outputVariables);
+    gl::LinkResult link(const gl::Data &data, gl::InfoLog &infoLog,
+                        gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                        const std::vector<std::string> &transformFeedbackVaryings,
+                        GLenum transformFeedbackBufferMode,
+                        int *registers, std::vector<gl::LinkedVarying> *linkedVaryings,
+                        std::map<int, gl::VariableLocation> *outputVariables);
 
     void getInputLayoutSignature(const gl::VertexFormat inputLayout[], GLenum signature[]) const;
 
@@ -115,8 +113,6 @@ class ProgramD3D : public ProgramImpl
 
     void reset();
 
-    unsigned int getSerial() const;
-
   private:
     DISALLOW_COPY_AND_ASSIGN(ProgramD3D);
 
@@ -216,11 +212,6 @@ class ProgramD3D : public ProgramImpl
     bool mDirtySamplerMapping;
 
     int mShaderVersion;
-
-    unsigned int mSerial;
-
-    static unsigned int issueSerial();
-    static unsigned int mCurrentSerial;
 };
 
 }

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -53,10 +53,10 @@ gl::Error RendererD3D::drawElements(const gl::Data &data,
                                     const GLvoid *indices, GLsizei instances,
                                     const RangeUI &indexRange)
 {
-    gl::Program *program = data.state->getProgram();
-    ASSERT(program != NULL);
+    ASSERT(data.state->getCurrentProgramId() != 0);
 
-    program->updateSamplerMapping();
+    gl::ProgramBinary *programBinary = data.state->getCurrentProgramBinary();
+    programBinary->updateSamplerMapping();
 
     gl::Error error = generateSwizzles(data);
     if (error.isError())
@@ -136,10 +136,10 @@ gl::Error RendererD3D::drawArrays(const gl::Data &data,
                                   GLenum mode, GLint first,
                                   GLsizei count, GLsizei instances)
 {
-    gl::Program *program = data.state->getProgram();
-    ASSERT(program != NULL);
+    ASSERT(data.state->getCurrentProgramId() != 0);
 
-    program->updateSamplerMapping();
+    gl::ProgramBinary *programBinary = data.state->getCurrentProgramBinary();
+    programBinary->updateSamplerMapping();
 
     gl::Error error = generateSwizzles(data);
     if (error.isError())
@@ -209,14 +209,14 @@ gl::Error RendererD3D::drawArrays(const gl::Data &data,
 
 gl::Error RendererD3D::generateSwizzles(const gl::Data &data, gl::SamplerType type)
 {
-    gl::Program *program = data.state->getProgram();
+    gl::ProgramBinary *programBinary = data.state->getCurrentProgramBinary();
 
-    size_t samplerRange = program->getUsedSamplerRange(type);
+    size_t samplerRange = programBinary->getUsedSamplerRange(type);
 
     for (size_t i = 0; i < samplerRange; i++)
     {
-        GLenum textureType = program->getSamplerTextureType(type, i);
-        GLint textureUnit = program->getSamplerMapping(type, i, *data.caps);
+        GLenum textureType = programBinary->getSamplerTextureType(type, i);
+        GLint textureUnit = programBinary->getSamplerMapping(type, i, *data.caps);
         if (textureUnit != -1)
         {
             gl::Texture *texture = data.state->getSamplerTexture(textureUnit, textureType);
@@ -355,20 +355,20 @@ bool RendererD3D::applyTransformFeedbackBuffers(const gl::Data &data)
 // Applies the shaders and shader constants to the Direct3D device
 gl::Error RendererD3D::applyShaders(const gl::Data &data, bool transformFeedbackActive)
 {
-    gl::Program *program = data.state->getProgram();
+    gl::ProgramBinary *programBinary = data.state->getCurrentProgramBinary();
 
     gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS];
-    gl::VertexFormat::GetInputLayout(inputLayout, program, *data.state);
+    gl::VertexFormat::GetInputLayout(inputLayout, programBinary, *data.state);
 
     const gl::Framebuffer *fbo = data.state->getDrawFramebuffer();
 
-    gl::Error error = applyShaders(program, inputLayout, fbo, data.state->getRasterizerState().rasterizerDiscard, transformFeedbackActive);
+    gl::Error error = applyShaders(programBinary, inputLayout, fbo, data.state->getRasterizerState().rasterizerDiscard, transformFeedbackActive);
     if (error.isError())
     {
         return error;
     }
 
-    return program->applyUniforms();
+    return programBinary->applyUniforms();
 }
 
 // For each Direct3D sampler of either the pixel or vertex stage,
@@ -377,13 +377,13 @@ gl::Error RendererD3D::applyShaders(const gl::Data &data, bool transformFeedback
 gl::Error RendererD3D::applyTextures(const gl::Data &data, gl::SamplerType shaderType,
                                      const FramebufferTextureSerialArray &framebufferSerials, size_t framebufferSerialCount)
 {
-    gl::Program *program = data.state->getProgram();
+    gl::ProgramBinary *programBinary = data.state->getCurrentProgramBinary();
 
-    size_t samplerRange = program->getUsedSamplerRange(shaderType);
+    size_t samplerRange = programBinary->getUsedSamplerRange(shaderType);
     for (size_t samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++)
     {
-        GLenum textureType = program->getSamplerTextureType(shaderType, samplerIndex);
-        GLint textureUnit = program->getSamplerMapping(shaderType, samplerIndex, *data.caps);
+        GLenum textureType = programBinary->getSamplerTextureType(shaderType, samplerIndex);
+        GLint textureUnit = programBinary->getSamplerMapping(shaderType, samplerIndex, *data.caps);
         if (textureUnit != -1)
         {
             gl::Texture *texture = data.state->getSamplerTexture(textureUnit, textureType);
@@ -471,13 +471,14 @@ gl::Error RendererD3D::applyTextures(const gl::Data &data)
 
 gl::Error RendererD3D::applyUniformBuffers(const gl::Data &data)
 {
-    gl::Program *program = data.state->getProgram();
+    gl::Program *programObject = data.resourceManager->getProgram(data.state->getCurrentProgramId());
+    gl::ProgramBinary *programBinary = programObject->getProgramBinary();
 
     std::vector<gl::Buffer*> boundBuffers;
 
-    for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < program->getActiveUniformBlockCount(); uniformBlockIndex++)
+    for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < programBinary->getActiveUniformBlockCount(); uniformBlockIndex++)
     {
-        GLuint blockBinding = program->getUniformBlockBinding(uniformBlockIndex);
+        GLuint blockBinding = programObject->getUniformBlockBinding(uniformBlockIndex);
 
         if (data.state->getIndexedUniformBuffer(blockBinding)->id() == 0)
         {
@@ -492,7 +493,7 @@ gl::Error RendererD3D::applyUniformBuffers(const gl::Data &data)
         }
     }
 
-    return program->applyUniformBuffers(boundBuffers, *data.caps);
+    return programBinary->applyUniformBuffers(boundBuffers, *data.caps);
 }
 
 bool RendererD3D::skipDraw(const gl::Data &data, GLenum drawMode)
@@ -502,7 +503,7 @@ bool RendererD3D::skipDraw(const gl::Data &data, GLenum drawMode)
         // ProgramBinary assumes non-point rendering if gl_PointSize isn't written,
         // which affects varying interpolation. Since the value of gl_PointSize is
         // undefined when not written, just skip drawing to avoid unexpected results.
-        if (!data.state->getProgram()->usesPointSize())
+        if (!data.state->getCurrentProgramBinary()->usesPointSize())
         {
             // This is stictly speaking not an error, but developers should be
             // notified of risking undefined behavior.

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -91,7 +91,7 @@ class RendererD3D : public Renderer
                              bool ignoreViewport) = 0;
 
     virtual gl::Error applyRenderTarget(const gl::Framebuffer *frameBuffer) = 0;
-    virtual gl::Error applyShaders(gl::Program *program, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
+    virtual gl::Error applyShaders(gl::ProgramBinary *programBinary, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
                                    bool rasterizerDiscard, bool transformFeedbackActive) = 0;
     virtual gl::Error applyUniforms(const ProgramImpl &program, const std::vector<gl::LinkedUniform*> &uniformArray) = 0;
     virtual bool applyPrimitiveType(GLenum primitiveType, GLsizei elementCount) = 0;

src/libANGLE/renderer/d3d/VertexDataManager.cpp

@@ -12,7 +12,7 @@
 #include "libANGLE/renderer/d3d/VertexBuffer.h"
 #include "libANGLE/renderer/Renderer.h"
 #include "libANGLE/Buffer.h"
-#include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/VertexAttribute.h"
 #include "libANGLE/State.h"
 
@@ -94,7 +94,7 @@ gl::Error VertexDataManager::prepareVertexData(const gl::State &state, GLint sta
     // Invalidate static buffers that don't contain matching attributes
     for (int attributeIndex = 0; attributeIndex < gl::MAX_VERTEX_ATTRIBS; attributeIndex++)
     {
-        translated[attributeIndex].active = (state.getProgram()->getSemanticIndex(attributeIndex) != -1);
+        translated[attributeIndex].active = (state.getCurrentProgramBinary()->getSemanticIndex(attributeIndex) != -1);
         const gl::VertexAttribute &curAttrib = state.getVertexAttribState(attributeIndex);
 
         if (translated[attributeIndex].active && curAttrib.enabled)

src/libANGLE/renderer/d3d/VertexDataManager.h

@@ -16,6 +16,7 @@
 
 namespace gl
 {
+class ProgramBinary;
 class State;
 struct VertexAttribute;
 struct VertexAttribCurrentValueData;

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

@@ -14,7 +14,7 @@
 #include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
-#include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/VertexAttribute.h"
 
 #include "third_party/murmurhash/MurmurHash3.h"
@@ -87,10 +87,10 @@ void InputLayoutCache::markDirty()
 }
 
 gl::Error InputLayoutCache::applyVertexBuffers(TranslatedAttribute attributes[gl::MAX_VERTEX_ATTRIBS],
-                                               gl::Program *program)
+                                               gl::ProgramBinary *programBinary)
 {
     int sortedSemanticIndices[gl::MAX_VERTEX_ATTRIBS];
-    program->sortAttributesByLayout(attributes, sortedSemanticIndices);
+    programBinary->sortAttributesByLayout(attributes, sortedSemanticIndices);
 
     if (!mDevice || !mDeviceContext)
     {
@@ -113,7 +113,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(TranslatedAttribute attributes[gl
             // Record the type of the associated vertex shader vector in our key
             // This will prevent mismatched vertex shaders from using the same input layout
             GLint attributeSize;
-            program->getActiveAttribute(ilKey.elementCount, 0, NULL, &attributeSize, &ilKey.elements[ilKey.elementCount].glslElementType, NULL);
+            programBinary->getActiveAttribute(ilKey.elementCount, 0, NULL, &attributeSize, &ilKey.elements[ilKey.elementCount].glslElementType, NULL);
 
             ilKey.elements[ilKey.elementCount].desc.SemanticName = semanticName;
             ilKey.elements[ilKey.elementCount].desc.SemanticIndex = sortedSemanticIndices[i];
@@ -138,7 +138,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(TranslatedAttribute attributes[gl
     {
         gl::VertexFormat shaderInputLayout[gl::MAX_VERTEX_ATTRIBS];
         GetInputLayout(attributes, shaderInputLayout);
-        ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(program->getImplementation());
+        ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(programBinary->getImplementation());
 
         ShaderExecutable *shader = NULL;
         gl::Error error = programD3D->getVertexExecutableForInputLayout(shaderInputLayout, &shader);

src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.h

@@ -21,7 +21,7 @@
 
 namespace gl
 {
-class Program;
+class ProgramBinary;
 }
 
 namespace rx
@@ -39,7 +39,7 @@ class InputLayoutCache
     void markDirty();
 
     gl::Error applyVertexBuffers(TranslatedAttribute attributes[gl::MAX_VERTEX_ATTRIBS],
-                                 gl::Program *program);
+                                 gl::ProgramBinary *programBinary);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(InputLayoutCache);

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

@@ -14,7 +14,7 @@
 #include "libANGLE/Display.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
-#include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/State.h"
 #include "libANGLE/Surface.h"
 #include "libANGLE/renderer/d3d/FramebufferD3D.h"
@@ -1073,7 +1073,7 @@ gl::Error Renderer11::applyVertexBuffer(const gl::State &state, GLint first, GLs
         return error;
     }
 
-    return mInputLayoutCache.applyVertexBuffers(attributes, state.getProgram());
+    return mInputLayoutCache.applyVertexBuffers(attributes, state.getCurrentProgramBinary());
 }
 
 gl::Error Renderer11::applyIndexBuffer(const GLvoid *indices, gl::Buffer *elementArrayBuffer, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo)
@@ -1478,10 +1478,10 @@ gl::Error Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error Renderer11::applyShaders(gl::Program *program, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
+gl::Error Renderer11::applyShaders(gl::ProgramBinary *programBinary, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
                                    bool rasterizerDiscard, bool transformFeedbackActive)
 {
-    ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(program->getImplementation());
+    ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(programBinary->getImplementation());
 
     ShaderExecutable *vertexExe = NULL;
     gl::Error error = programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe);

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -82,7 +82,7 @@ class Renderer11 : public RendererD3D
 
     virtual bool applyPrimitiveType(GLenum mode, GLsizei count);
     gl::Error applyRenderTarget(const gl::Framebuffer *frameBuffer) override;
-    virtual gl::Error applyShaders(gl::Program *program, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
+    virtual gl::Error applyShaders(gl::ProgramBinary *programBinary, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
                                    bool rasterizerDiscard, bool transformFeedbackActive);
 
     virtual gl::Error applyUniforms(const ProgramImpl &program, const std::vector<gl::LinkedUniform*> &uniformArray);

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

@@ -11,7 +11,7 @@
 #include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
 #include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
 #include "libANGLE/renderer/Workarounds.h"
-#include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/Framebuffer.h"
 
 #include "common/debug.h"

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -13,7 +13,7 @@
 #include "libANGLE/Display.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
-#include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/Renderbuffer.h"
 #include "libANGLE/State.h"
 #include "libANGLE/Surface.h"
@@ -1320,7 +1320,7 @@ gl::Error Renderer9::applyVertexBuffer(const gl::State &state, GLint first, GLsi
         return error;
     }
 
-    return mVertexDeclarationCache.applyDeclaration(mDevice, attributes, state.getProgram(), instances, &mRepeatDraw);
+    return mVertexDeclarationCache.applyDeclaration(mDevice, attributes, state.getCurrentProgramBinary(), instances, &mRepeatDraw);
 }
 
 // Applies the indices and element array bindings to the Direct3D 9 device
@@ -1719,13 +1719,13 @@ gl::Error Renderer9::getCountingIB(size_t count, StaticIndexBufferInterface **ou
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error Renderer9::applyShaders(gl::Program *program, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
+gl::Error Renderer9::applyShaders(gl::ProgramBinary *programBinary, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
                                   bool rasterizerDiscard, bool transformFeedbackActive)
 {
     ASSERT(!transformFeedbackActive);
     ASSERT(!rasterizerDiscard);
 
-    ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(program->getImplementation());
+    ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(programBinary->getImplementation());
 
     ShaderExecutable *vertexExe = NULL;
     gl::Error error = programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe);
@@ -1761,7 +1761,7 @@ gl::Error Renderer9::applyShaders(gl::Program *program, const gl::VertexFormat i
     // per-program, checking the program serial guarantees we upload fresh
     // uniform data even if our shader pointers are the same.
     // https://code.google.com/p/angleproject/issues/detail?id=661
-    unsigned int programSerial = programD3D->getSerial();
+    unsigned int programSerial = programBinary->getSerial();
     if (programSerial != mAppliedProgramSerial)
     {
         programD3D->dirtyAllUniforms();

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -82,7 +82,7 @@ class Renderer9 : public RendererD3D
                              bool ignoreViewport);
 
     gl::Error applyRenderTarget(const gl::Framebuffer *frameBuffer) override;
-    virtual gl::Error applyShaders(gl::Program *program, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
+    virtual gl::Error applyShaders(gl::ProgramBinary *programBinary, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
                                    bool rasterizerDiscard, bool transformFeedbackActive);
     virtual gl::Error applyUniforms(const ProgramImpl &program, const std::vector<gl::LinkedUniform*> &uniformArray);
     virtual bool applyPrimitiveType(GLenum primitiveType, GLsizei elementCount);

src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.cpp

@@ -9,7 +9,7 @@
 #include "libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h"
 #include "libANGLE/renderer/d3d/d3d9/VertexBuffer9.h"
 #include "libANGLE/renderer/d3d/d3d9/formatutils9.h"
-#include "libANGLE/Program.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/VertexAttribute.h"
 
 namespace rx
@@ -40,7 +40,7 @@ VertexDeclarationCache::~VertexDeclarationCache()
     }
 }
 
-gl::Error VertexDeclarationCache::applyDeclaration(IDirect3DDevice9 *device, TranslatedAttribute attributes[], gl::Program *program, GLsizei instances, GLsizei *repeatDraw)
+gl::Error VertexDeclarationCache::applyDeclaration(IDirect3DDevice9 *device, TranslatedAttribute attributes[], gl::ProgramBinary *programBinary, GLsizei instances, GLsizei *repeatDraw)
 {
     *repeatDraw = 1;
 
@@ -155,7 +155,7 @@ gl::Error VertexDeclarationCache::applyDeclaration(IDirect3DDevice9 *device, Tra
             element->Type = d3d9VertexInfo.nativeFormat;
             element->Method = D3DDECLMETHOD_DEFAULT;
             element->Usage = D3DDECLUSAGE_TEXCOORD;
-            element->UsageIndex = program->getSemanticIndex(i);
+            element->UsageIndex = programBinary->getSemanticIndex(i);
             element++;
         }
     }

src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h

@@ -15,7 +15,6 @@
 namespace gl
 {
 class VertexDataManager;
-class Program;
 }
 
 namespace rx
@@ -27,7 +26,7 @@ class VertexDeclarationCache
     VertexDeclarationCache();
     ~VertexDeclarationCache();
 
-    gl::Error applyDeclaration(IDirect3DDevice9 *device, TranslatedAttribute attributes[], gl::Program *program, GLsizei instances, GLsizei *repeatDraw);
+    gl::Error applyDeclaration(IDirect3DDevice9 *device, TranslatedAttribute attributes[], gl::ProgramBinary *programBinary, GLsizei instances, GLsizei *repeatDraw);
 
     void markStateDirty();
 

src/libANGLE/validationES.cpp

@@ -15,8 +15,7 @@
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/Query.h"
-#include "libANGLE/Program.h"
-#include "libANGLE/Uniform.h"
+#include "libANGLE/ProgramBinary.h"
 #include "libANGLE/TransformFeedback.h"
 #include "libANGLE/VertexArray.h"
 #include "libANGLE/renderer/BufferImpl.h"
@@ -1059,8 +1058,8 @@ static bool ValidateUniformCommonBase(gl::Context *context, GLenum targetUniform
         return false;
     }
 
-    gl::Program *program = context->getState().getProgram();
-    if (!program)
+    gl::ProgramBinary *programBinary = context->getState().getCurrentProgramBinary();
+    if (!programBinary)
     {
         context->recordError(Error(GL_INVALID_OPERATION));
         return false;
@@ -1072,13 +1071,13 @@ static bool ValidateUniformCommonBase(gl::Context *context, GLenum targetUniform
         return false;
     }
 
-    if (!program->isValidUniformLocation(location))
+    if (!programBinary->isValidUniformLocation(location))
     {
         context->recordError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
-    LinkedUniform *uniform = program->getUniformByLocation(location);
+    LinkedUniform *uniform = programBinary->getUniformByLocation(location);
 
     // attempting to write an array to a non-array uniform is an INVALID_OPERATION
     if (uniform->elementCount() == 1 && count > 1)
@@ -1462,14 +1461,14 @@ static bool ValidateDrawBase(Context *context, GLenum mode, GLsizei count, GLsiz
         return false;
     }
 
-    gl::Program *program = state.getProgram();
-    if (!program)
+    if (state.getCurrentProgramId() == 0)
     {
         context->recordError(Error(GL_INVALID_OPERATION));
         return false;
     }
 
-    if (!program->validateSamplers(NULL, context->getCaps()))
+    gl::ProgramBinary *programBinary = state.getCurrentProgramBinary();
+    if (!programBinary->validateSamplers(NULL, context->getCaps()))
     {
         context->recordError(Error(GL_INVALID_OPERATION));
         return false;
@@ -1480,7 +1479,7 @@ static bool ValidateDrawBase(Context *context, GLenum mode, GLsizei count, GLsiz
     for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
     {
         const VertexAttribute &attrib = vao->getVertexAttribute(attributeIndex);
-        bool attribActive = (program->getSemanticIndex(attributeIndex) != -1);
+        bool attribActive = (programBinary->getSemanticIndex(attributeIndex) != -1);
         if (attribActive && attrib.enabled)
         {
             gl::Buffer *buffer = attrib.buffer.get();
@@ -1574,13 +1573,13 @@ static bool ValidateDrawInstancedANGLE(Context *context)
     // Verify there is at least one active attribute with a divisor of zero
     const gl::State& state = context->getState();
 
-    gl::Program *program = state.getProgram();
+    gl::ProgramBinary *programBinary = state.getCurrentProgramBinary();
 
     const VertexArray *vao = state.getVertexArray();
     for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
     {
         const VertexAttribute &attrib = vao->getVertexAttribute(attributeIndex);
-        bool active = (program->getSemanticIndex(attributeIndex) != -1);
+        bool active = (programBinary->getSemanticIndex(attributeIndex) != -1);
         if (active && attrib.divisor == 0)
         {
             return true;
@@ -1887,7 +1886,14 @@ bool ValidateGetUniformBase(Context *context, GLuint program, GLint location)
         return false;
     }
 
-    if (!programObject->isValidUniformLocation(location))
+    gl::ProgramBinary *programBinary = programObject->getProgramBinary();
+    if (!programBinary)
+    {
+        context->recordError(Error(GL_INVALID_OPERATION));
+        return false;
+    }
+
+    if (!programBinary->isValidUniformLocation(location))
     {
         context->recordError(Error(GL_INVALID_OPERATION));
         return false;
@@ -1915,9 +1921,10 @@ static bool ValidateSizedGetUniform(Context *context, GLuint program, GLint loca
 
     gl::Program *programObject = context->getProgram(program);
     ASSERT(programObject);
+    gl::ProgramBinary *programBinary = programObject->getProgramBinary();
 
     // sized queries -- ensure the provided buffer is large enough
-    LinkedUniform *uniform = programObject->getUniformByLocation(location);
+    LinkedUniform *uniform = programBinary->getUniformByLocation(location);
     size_t requiredBytes = VariableExternalSize(uniform->type);
     if (static_cast<size_t>(bufSize) < requiredBytes)
     {

src/libGLESv2.gypi

@@ -74,6 +74,8 @@
             'libANGLE/ImageIndex.cpp',
             'libANGLE/Program.cpp',
             'libANGLE/Program.h',
+            'libANGLE/ProgramBinary.cpp',
+            'libANGLE/ProgramBinary.h',
             'libANGLE/Query.cpp',
             'libANGLE/Query.h',
             'libANGLE/RefCountObject.cpp',