Moving Shader Executables into ProgramD3D

src/libGLESv2/BinaryStream.h

@@ -15,6 +15,7 @@
 #include <cstddef>
 #include <string>
 #include <vector>
+#include <stdint.h>
 
 namespace gl
 {
@@ -26,7 +27,7 @@ class BinaryInputStream
     {
         mError = false;
         mOffset = 0;
-        mData = static_cast<const char*>(data);
+        mData = static_cast<const uint8_t*>(data);
         mLength = length;
     }
 
@@ -85,7 +86,7 @@ class BinaryInputStream
             return;
         }
 
-        v->assign(mData + mOffset, length);
+        v->assign(reinterpret_cast<const char *>(mData) + mOffset, length);
         mOffset += length;
     }
 
@@ -115,11 +116,16 @@ class BinaryInputStream
         return mOffset == mLength;
     }
 
+    const uint8_t *data()
+    {
+        return mData;
+    }
+
   private:
     DISALLOW_COPY_AND_ASSIGN(BinaryInputStream);
     bool mError;
     size_t mOffset;
-    const char *mData;
+    const uint8_t *mData;
     size_t mLength;
 
     template <typename T>

src/libGLESv2/ProgramBinary.h

@@ -101,11 +101,6 @@ class ProgramBinary : public RefCountObject
     rx::ProgramImpl *getImplementation() { return mProgram; }
     const rx::ProgramImpl *getImplementation() const { return mProgram; }
 
-    rx::ShaderExecutable *getPixelExecutableForFramebuffer(const Framebuffer *fbo);
-    rx::ShaderExecutable *getPixelExecutableForOutputLayout(const std::vector<GLenum> &outputLayout);
-    rx::ShaderExecutable *getVertexExecutableForInputLayout(const VertexFormat inputLayout[MAX_VERTEX_ATTRIBS]);
-    rx::ShaderExecutable *getGeometryExecutable() const;
-
     GLuint getAttributeLocation(const char *name);
     int getSemanticIndex(int attributeIndex);
 
@@ -250,56 +245,12 @@ class ProgramBinary : public RefCountObject
     template <typename T>
     void getUniformv(GLint location, T *params, GLenum uniformType);
 
-    class VertexExecutable
-    {
-      public:
-        VertexExecutable(const VertexFormat inputLayout[MAX_VERTEX_ATTRIBS],
-                         const GLenum signature[MAX_VERTEX_ATTRIBS],
-                         rx::ShaderExecutable *shaderExecutable);
-        ~VertexExecutable();
-
-        bool matchesSignature(const GLenum convertedLayout[MAX_VERTEX_ATTRIBS]) const;
-
-        const VertexFormat *inputs() const { return mInputs; }
-        const GLenum *signature() const { return mSignature; }
-        rx::ShaderExecutable *shaderExecutable() const { return mShaderExecutable; }
-
-      private:
-        VertexFormat mInputs[MAX_VERTEX_ATTRIBS];
-        GLenum mSignature[MAX_VERTEX_ATTRIBS];
-        rx::ShaderExecutable *mShaderExecutable;
-    };
-
-    class PixelExecutable
-    {
-      public:
-        PixelExecutable(const std::vector<GLenum> &outputSignature, rx::ShaderExecutable *shaderExecutable);
-        ~PixelExecutable();
-
-        bool matchesSignature(const std::vector<GLenum> &signature) const { return mOutputSignature == signature; }
-
-        const std::vector<GLenum> &outputSignature() const { return mOutputSignature; }
-        rx::ShaderExecutable *shaderExecutable() const { return mShaderExecutable; }
-
-      private:
-        std::vector<GLenum> mOutputSignature;
-        rx::ShaderExecutable *mShaderExecutable;
-    };
-
     rx::ProgramImpl *mProgram;
 
-    std::vector<VertexExecutable *> mVertexExecutables;
-    std::vector<PixelExecutable *> mPixelExecutables;
-    rx::ShaderExecutable *mGeometryExecutable;
-
     sh::Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS];
-    sh::Attribute mShaderAttributes[MAX_VERTEX_ATTRIBS];
     int mSemanticIndex[MAX_VERTEX_ATTRIBS];
     int mAttributesByLayout[MAX_VERTEX_ATTRIBS];
 
-    GLenum mTransformFeedbackBufferMode;
-    std::vector<LinkedVarying> mTransformFeedbackLinkedVaryings;
-
     std::vector<Sampler> mSamplersPS;
     std::vector<Sampler> mSamplersVS;
     GLuint mUsedVertexSamplerRange;

src/libGLESv2/renderer/ProgramImpl.h

@@ -25,37 +25,23 @@ class ProgramImpl
 public:
     virtual ~ProgramImpl() { }
 
-    virtual const std::vector<rx::PixelShaderOutputVariable> &getPixelShaderKey() = 0;
-
     virtual bool usesPointSize() const = 0;
-    virtual bool usesGeometryShader() const = 0;
     virtual int getShaderVersion() const = 0;
+    virtual GLenum getTransformFeedbackBufferMode() const = 0;
+    virtual std::vector<gl::LinkedVarying> &getTransformFeedbackLinkedVaryings() = 0;
+    virtual sh::Attribute *getShaderAttributes() = 0;
 
     virtual GLenum getBinaryFormat() = 0;
     virtual bool load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream) = 0;
     virtual bool save(gl::BinaryOutputStream *stream) = 0;
 
-    virtual rx::ShaderExecutable *getPixelExecutableForOutputLayout(gl::InfoLog &infoLog, const std::vector<GLenum> &outputSignature,
-                                                                    const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
-                                                                    bool separatedOutputBuffers) = 0;
-    virtual rx::ShaderExecutable *getVertexExecutableForInputLayout(gl::InfoLog &infoLog,
-                                                                    const gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS],
-                                                                    const sh::Attribute shaderAttributes[],
-                                                                    const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
-                                                                    bool separatedOutputBuffers) = 0;
-    virtual rx::ShaderExecutable *getGeometryExecutable(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                                                        const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
-                                                        bool separatedOutputBuffers, int registers) = 0;
-    virtual rx::ShaderExecutable *loadExecutable(const void *function, size_t length, rx::ShaderType type,
-                                                 const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
-                                                 bool separatedOutputBuffers) = 0;
+    virtual bool compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                           int registers) = 0;
 
     virtual bool link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                      const std::vector<std::string> &transformFeedbackVaryings, int *registers,
-                      std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int,
-                      gl::VariableLocation> *outputVariables) = 0;
-
-    virtual void getInputLayoutSignature(const gl::VertexFormat inputLayout[], GLenum signature[]) const = 0;
+                      const std::vector<std::string> &transformFeedbackVaryings, GLenum transformFeedbackBufferMode,
+                      int *registers, std::vector<gl::LinkedVarying> *linkedVaryings,
+                      std::map<int, gl::VariableLocation> *outputVariables, const gl::Caps &caps) = 0;
 
     virtual void initializeUniformStorage(const std::vector<gl::LinkedUniform*> &uniforms) = 0;
 

src/libGLESv2/renderer/d3d/ProgramD3D.h

@@ -37,8 +37,11 @@ class ProgramD3D : public ProgramImpl
 
     const std::vector<rx::PixelShaderOutputVariable> &getPixelShaderKey() { return mPixelShaderKey; }
     int getShaderVersion() const { return mShaderVersion; }
+    GLenum getTransformFeedbackBufferMode() const { return mTransformFeedbackBufferMode; }
+    std::vector<gl::LinkedVarying> &getTransformFeedbackLinkedVaryings() { return mTransformFeedbackLinkedVaryings; }
+    sh::Attribute *getShaderAttributes() { return mShaderAttributes; }
 
-    bool usesPointSize() const;
+    bool usesPointSize() const { return mUsesPointSize; }
     bool usesPointSpriteEmulation() const;
     bool usesGeometryShader() const;
 
@@ -46,24 +49,18 @@ class ProgramD3D : public ProgramImpl
     bool load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream);
     bool save(gl::BinaryOutputStream *stream);
 
-    ShaderExecutable *getPixelExecutableForOutputLayout(gl::InfoLog &infoLog, const std::vector<GLenum> &outputSignature,
-                                                        const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
-                                                        bool separatedOutputBuffers);
-    ShaderExecutable *getVertexExecutableForInputLayout(gl::InfoLog &infoLog,
-                                                        const gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS],
-                                                        const sh::Attribute shaderAttributes[],
-                                                        const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
-                                                        bool separatedOutputBuffers);
-    ShaderExecutable *getGeometryExecutable(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                                            const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
-                                            bool separatedOutputBuffers, int registers);
-    ShaderExecutable *loadExecutable(const void *function, size_t length, rx::ShaderType type,
-                                     const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
-                                     bool separatedOutputBuffers);
+    ShaderExecutable *getPixelExecutableForFramebuffer(const gl::Framebuffer *fbo);
+    ShaderExecutable *getPixelExecutableForOutputLayout(const std::vector<GLenum> &outputLayout);
+    ShaderExecutable *getVertexExecutableForInputLayout(const gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS]);
+    ShaderExecutable *getGeometryExecutable() const { return mGeometryExecutable; }
+
+    bool compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                   int registers);
 
     bool link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-              const std::vector<std::string> &transformFeedbackVaryings, int *registers,
-              std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int, gl::VariableLocation> *outputVariables);
+              const std::vector<std::string> &transformFeedbackVaryings, GLenum transformFeedbackBufferMode,
+              int *registers, std::vector<gl::LinkedVarying> *linkedVaryings,
+              std::map<int, gl::VariableLocation> *outputVariables, const gl::Caps &caps);
 
     void getInputLayoutSignature(const gl::VertexFormat inputLayout[], GLenum signature[]) const;
 
@@ -83,9 +80,49 @@ class ProgramD3D : public ProgramImpl
   private:
     DISALLOW_COPY_AND_ASSIGN(ProgramD3D);
 
+    class VertexExecutable
+    {
+      public:
+        VertexExecutable(const gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS],
+                         const GLenum signature[gl::MAX_VERTEX_ATTRIBS],
+                         rx::ShaderExecutable *shaderExecutable);
+        ~VertexExecutable();
+
+        bool matchesSignature(const GLenum convertedLayout[gl::MAX_VERTEX_ATTRIBS]) const;
+
+        const gl::VertexFormat *inputs() const { return mInputs; }
+        const GLenum *signature() const { return mSignature; }
+        rx::ShaderExecutable *shaderExecutable() const { return mShaderExecutable; }
+
+      private:
+        gl::VertexFormat mInputs[gl::MAX_VERTEX_ATTRIBS];
+        GLenum mSignature[gl::MAX_VERTEX_ATTRIBS];
+        rx::ShaderExecutable *mShaderExecutable;
+    };
+
+    class PixelExecutable
+    {
+      public:
+        PixelExecutable(const std::vector<GLenum> &outputSignature, rx::ShaderExecutable *shaderExecutable);
+        ~PixelExecutable();
+
+        bool matchesSignature(const std::vector<GLenum> &signature) const { return mOutputSignature == signature; }
+
+        const std::vector<GLenum> &outputSignature() const { return mOutputSignature; }
+        rx::ShaderExecutable *shaderExecutable() const { return mShaderExecutable; }
+
+      private:
+        std::vector<GLenum> mOutputSignature;
+        rx::ShaderExecutable *mShaderExecutable;
+    };
+
     Renderer *mRenderer;
     DynamicHLSL *mDynamicHLSL;
 
+    std::vector<VertexExecutable *> mVertexExecutables;
+    std::vector<PixelExecutable *> mPixelExecutables;
+    rx::ShaderExecutable *mGeometryExecutable;
+
     std::string mVertexHLSL;
     rx::D3DWorkaroundType mVertexWorkarounds;
 
@@ -99,6 +136,11 @@ class ProgramD3D : public ProgramImpl
     UniformStorage *mVertexUniformStorage;
     UniformStorage *mFragmentUniformStorage;
 
+    GLenum mTransformFeedbackBufferMode;
+    std::vector<gl::LinkedVarying> mTransformFeedbackLinkedVaryings;
+
+    sh::Attribute mShaderAttributes[gl::MAX_VERTEX_ATTRIBS];
+
     int mShaderVersion;
 };
 

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

@@ -12,6 +12,7 @@
 #include "libGLESv2/renderer/d3d/d3d11/Buffer11.h"
 #include "libGLESv2/renderer/d3d/d3d11/ShaderExecutable11.h"
 #include "libGLESv2/renderer/d3d/d3d11/formatutils11.h"
+#include "libGLESv2/renderer/d3d/ProgramD3D.h"
 #include "libGLESv2/renderer/d3d/VertexDataManager.h"
 #include "libGLESv2/ProgramBinary.h"
 #include "libGLESv2/VertexAttribute.h"
@@ -137,7 +138,8 @@ gl::Error InputLayoutCache::applyVertexBuffers(TranslatedAttribute attributes[gl
     {
         gl::VertexFormat shaderInputLayout[gl::MAX_VERTEX_ATTRIBS];
         GetInputLayout(attributes, shaderInputLayout);
-        ShaderExecutable11 *shader = ShaderExecutable11::makeShaderExecutable11(programBinary->getVertexExecutableForInputLayout(shaderInputLayout));
+        ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(programBinary->getImplementation());
+        ShaderExecutable11 *shader = ShaderExecutable11::makeShaderExecutable11(programD3D->getVertexExecutableForInputLayout(shaderInputLayout));
 
         D3D11_INPUT_ELEMENT_DESC descs[gl::MAX_VERTEX_ATTRIBS];
         for (unsigned int j = 0; j < ilKey.elementCount; ++j)

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

@@ -1329,9 +1329,10 @@ gl::Error Renderer11::drawTriangleFan(GLsizei count, GLenum type, const GLvoid *
 gl::Error Renderer11::applyShaders(gl::ProgramBinary *programBinary, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
                                    bool rasterizerDiscard, bool transformFeedbackActive)
 {
-    ShaderExecutable *vertexExe = programBinary->getVertexExecutableForInputLayout(inputLayout);
-    ShaderExecutable *pixelExe = programBinary->getPixelExecutableForFramebuffer(framebuffer);
-    ShaderExecutable *geometryExe = programBinary->getGeometryExecutable();
+    ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(programBinary->getImplementation());
+    ShaderExecutable *vertexExe = programD3D->getVertexExecutableForInputLayout(inputLayout);
+    ShaderExecutable *pixelExe = programD3D->getPixelExecutableForFramebuffer(framebuffer);
+    ShaderExecutable *geometryExe = programD3D->getGeometryExecutable();
 
     ID3D11VertexShader *vertexShader = (vertexExe ? ShaderExecutable11::makeShaderExecutable11(vertexExe)->getVertexShader() : NULL);
 

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

@@ -1670,8 +1670,9 @@ gl::Error Renderer9::applyShaders(gl::ProgramBinary *programBinary, const gl::Ve
     ASSERT(!transformFeedbackActive);
     ASSERT(!rasterizerDiscard);
 
-    ShaderExecutable *vertexExe = programBinary->getVertexExecutableForInputLayout(inputLayout);
-    ShaderExecutable *pixelExe = programBinary->getPixelExecutableForFramebuffer(framebuffer);
+    ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(programBinary->getImplementation());
+    ShaderExecutable *vertexExe = programD3D->getVertexExecutableForInputLayout(inputLayout);
+    ShaderExecutable *pixelExe = programD3D->getPixelExecutableForFramebuffer(framebuffer);
 
     IDirect3DVertexShader9 *vertexShader = (vertexExe ? ShaderExecutable9::makeShaderExecutable9(vertexExe)->getVertexShader() : NULL);
     IDirect3DPixelShader9 *pixelShader = (pixelExe ? ShaderExecutable9::makeShaderExecutable9(pixelExe)->getPixelShader() : NULL);