Store the shader bytecode in ShaderExecutable to pass it to CreateInputLayout.

src/libGLESv2/ProgramBinary.cpp

@@ -1733,14 +1733,10 @@ bool ProgramBinary::save(void* binary, GLsizei bufSize, GLsizei *length)
     stream.write(mDxFrontCCWLocation);
     stream.write(mDxPointsOrLinesLocation);
 
-    UINT pixelShaderSize;
-    bool result = mPixelExecutable->getPixelFunction(NULL, &pixelShaderSize);
-    ASSERT(result);
+    UINT pixelShaderSize = mPixelExecutable->getLength();
     stream.write(pixelShaderSize);
 
-    UINT vertexShaderSize;
-    result = mVertexExecutable->getVertexFunction(NULL, &vertexShaderSize);
-    ASSERT(result);
+    UINT vertexShaderSize = mVertexExecutable->getLength();
     stream.write(vertexShaderSize);
 
     GUID identifier = mRenderer->getAdapterIdentifier();
@@ -1769,12 +1765,10 @@ bool ProgramBinary::save(void* binary, GLsizei bufSize, GLsizei *length)
         memcpy(ptr, &identifier, sizeof(GUID));
         ptr += sizeof(GUID);
 
-        result = mPixelExecutable->getPixelFunction(ptr, &pixelShaderSize);
-        ASSERT(result);
+        memcpy(ptr, mPixelExecutable->getFunction(), pixelShaderSize);
         ptr += pixelShaderSize;
 
-        result = mVertexExecutable->getVertexFunction(ptr, &vertexShaderSize);
-        ASSERT(result);
+        memcpy(ptr, mVertexExecutable->getFunction(), vertexShaderSize);
         ptr += vertexShaderSize;
 
         ASSERT(ptr - totalLength == binary);

src/libGLESv2/renderer/Renderer.h

@@ -161,7 +161,7 @@ class Renderer
     virtual RenderTarget *createRenderTarget(int width, int height, GLenum format, GLsizei samples, bool depth) = 0;
 
     // Shader operations
-    virtual ShaderExecutable *loadExecutable(const DWORD *function, size_t length, GLenum type, void *data) = 0;
+    virtual ShaderExecutable *loadExecutable(const void *function, size_t length, GLenum type, void *data) = 0;
     virtual ShaderExecutable *compileToExecutable(gl::InfoLog &infoLog, const char *shaderHLSL, GLenum type) = 0;
 
   protected:

src/libGLESv2/renderer/Renderer11.cpp

@@ -683,8 +683,10 @@ GLenum Renderer11::applyVertexBuffer(gl::ProgramBinary *programBinary, gl::Verte
         {"TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}
     };
 
+    ShaderExecutable *vertexExecutable = programBinary->getVertexExecutable();
+
     ID3D11InputLayout *inputLayout = NULL;
-    result = mDevice->CreateInputLayout(inputElementDescriptions, 1, NULL /*FIXME: vertex shader blob */, 0 /* FIXME: vertex shader size */, &inputLayout);
+    result = mDevice->CreateInputLayout(inputElementDescriptions, 1, vertexExecutable->getFunction(), vertexExecutable->getLength(), &inputLayout);
     ASSERT(SUCCEEDED(result));
     
     mDeviceContext->IASetInputLayout(inputLayout);
@@ -1178,7 +1180,7 @@ RenderTarget *Renderer11::createRenderTarget(int width, int height, GLenum forma
     return NULL;
 }
 
-ShaderExecutable *Renderer11::loadExecutable(const DWORD *function, size_t length, GLenum type, void *data)
+ShaderExecutable *Renderer11::loadExecutable(const void *function, size_t length, GLenum type, void *data)
 {
     ShaderExecutable11 *executable = NULL;
 
@@ -1192,7 +1194,7 @@ ShaderExecutable *Renderer11::loadExecutable(const DWORD *function, size_t lengt
 
             if (vshader)
             {
-                executable = new ShaderExecutable11(vshader);
+                executable = new ShaderExecutable11(function, length, vshader);
             }
         }
         break;
@@ -1204,7 +1206,7 @@ ShaderExecutable *Renderer11::loadExecutable(const DWORD *function, size_t lengt
 
             if (pshader)
             {
-                executable = new ShaderExecutable11(pshader);
+                executable = new ShaderExecutable11(function, length, pshader);
             }
         }
         break;

src/libGLESv2/renderer/Renderer11.h

@@ -129,7 +129,7 @@ class Renderer11 : public Renderer
     virtual RenderTarget *createRenderTarget(int width, int height, GLenum format, GLsizei samples, bool depth);
 
     // Shader operations
-    virtual ShaderExecutable *loadExecutable(const DWORD *function, size_t length, GLenum type, void *data);
+    virtual ShaderExecutable *loadExecutable(const void *function, size_t length, GLenum type, void *data);
     virtual ShaderExecutable *compileToExecutable(gl::InfoLog &infoLog, const char *shaderHLSL, GLenum type);
 
     // D3D11-renderer specific methods

src/libGLESv2/renderer/Renderer9.cpp

@@ -2647,7 +2647,7 @@ RenderTarget *Renderer9::createRenderTarget(int width, int height, GLenum format
     return renderTarget;
 }
 
-ShaderExecutable *Renderer9::loadExecutable(const DWORD *function, size_t length, GLenum type, void *data)
+ShaderExecutable *Renderer9::loadExecutable(const void *function, size_t length, GLenum type, void *data)
 {
     ShaderExecutable9 *executable = NULL;
     gl::D3DConstantTable *table = reinterpret_cast<gl::D3DConstantTable *>(data);
@@ -2656,19 +2656,19 @@ ShaderExecutable *Renderer9::loadExecutable(const DWORD *function, size_t length
     {
       case GL_VERTEX_SHADER:
         {
-            IDirect3DVertexShader9 *vshader = createVertexShader(function, length);
+            IDirect3DVertexShader9 *vshader = createVertexShader((DWORD*)function, length);
             if (vshader)
             {
-                executable = new ShaderExecutable9(vshader, table);
+                executable = new ShaderExecutable9(function, length, vshader, table);
             }
         }
         break;
       case GL_FRAGMENT_SHADER:
         {
-            IDirect3DPixelShader9 *pshader = createPixelShader(function, length);
+            IDirect3DPixelShader9 *pshader = createPixelShader((DWORD*)function, length);
             if (pshader)
             {
-                executable = new ShaderExecutable9(pshader, table);
+                executable = new ShaderExecutable9(function, length, pshader, table);
             }
         }
         break;
@@ -2702,7 +2702,7 @@ ShaderExecutable *Renderer9::compileToExecutable(gl::InfoLog &infoLog, const cha
     if (!binary)
         return NULL;
 
-    ShaderExecutable *executable = loadExecutable((DWORD *)binary->GetBufferPointer(), binary->GetBufferSize(), type, constantTable);
+    ShaderExecutable *executable = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type, constantTable);
     binary->Release();
 
     return executable;

src/libGLESv2/renderer/Renderer9.h

@@ -168,7 +168,7 @@ class Renderer9 : public Renderer
     virtual RenderTarget *createRenderTarget(int width, int height, GLenum format, GLsizei samples, bool depth);
 
     // Shader operations
-    virtual ShaderExecutable *loadExecutable(const DWORD *function, size_t length, GLenum type, void *data);
+    virtual ShaderExecutable *loadExecutable(const void *function, size_t length, GLenum type, void *data);
     virtual ShaderExecutable *compileToExecutable(gl::InfoLog &infoLog, const char *shaderHLSL, GLenum type);
 
     // D3D9-renderer specific methods

src/libGLESv2/renderer/ShaderExecutable.h

@@ -19,16 +19,34 @@ namespace rx
 class ShaderExecutable
 {
   public:
-    ShaderExecutable() {};
-    virtual ~ShaderExecutable() {};
-
-    virtual bool getVertexFunction(void *pData, UINT *pSizeOfData) = 0;
-    virtual bool getPixelFunction(void *pData, UINT *pSizeOfData) = 0;
+    ShaderExecutable(const void *function, size_t length) : mLength(length)
+    {
+        mFunction = new char[length];
+        memcpy(mFunction, function, length);
+    }
+    
+    virtual ~ShaderExecutable()
+    {
+        delete mFunction;
+    }
+
+    void *getFunction() const
+    {
+        return mFunction;
+    }
+
+    size_t getLength() const
+    {
+        return mLength;
+    }
 
     virtual gl::D3DConstantTable *getConstantTable() = 0; // D3D9_REMOVE
 
   private:
     DISALLOW_COPY_AND_ASSIGN(ShaderExecutable);
+
+    void *mFunction;
+    const size_t mLength;
 };
 
 }

src/libGLESv2/renderer/ShaderExecutable11.cpp

@@ -14,13 +14,15 @@
 namespace rx
 {
 
-ShaderExecutable11::ShaderExecutable11(ID3D11PixelShader *executable)
+ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11PixelShader *executable)
+    : ShaderExecutable(function, length)
 {
     mPixelExecutable = executable;
     mVertexExecutable = NULL;
 }
 
-ShaderExecutable11::ShaderExecutable11(ID3D11VertexShader *executable)
+ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable)
+    : ShaderExecutable(function, length)
 {
     mVertexExecutable = executable;
     mPixelExecutable = NULL;
@@ -44,20 +46,6 @@ ShaderExecutable11 *ShaderExecutable11::makeShaderExecutable11(ShaderExecutable
     return static_cast<ShaderExecutable11*>(executable);
 }
 
-bool ShaderExecutable11::getVertexFunction(void *pData, UINT *pSizeOfData)
-{
-    // TODO
-    UNIMPLEMENTED();
-    return false;
-}
-
-bool ShaderExecutable11::getPixelFunction(void *pData, UINT *pSizeOfData)
-{
-    // TODO
-    UNIMPLEMENTED();
-    return false;
-}
-
 ID3D11VertexShader *ShaderExecutable11::getVertexShader()
 {
     return mVertexExecutable;

src/libGLESv2/renderer/ShaderExecutable11.h

@@ -20,12 +20,10 @@ namespace rx
 class ShaderExecutable11 : public ShaderExecutable
 {
   public:
-    ShaderExecutable11(ID3D11PixelShader *executable);
-    ShaderExecutable11(ID3D11VertexShader *executable);
-    virtual ~ShaderExecutable11();
+    ShaderExecutable11(const void *function, size_t length, ID3D11PixelShader *executable);
+    ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable);
 
-    virtual bool getVertexFunction(void *pData, UINT *pSizeOfData);
-    virtual bool getPixelFunction(void *pData, UINT *pSizeOfData);
+    virtual ~ShaderExecutable11();
 
     static ShaderExecutable11 *makeShaderExecutable11(ShaderExecutable *executable);
 

src/libGLESv2/renderer/ShaderExecutable9.cpp

@@ -14,14 +14,16 @@
 namespace rx
 {
 
-ShaderExecutable9::ShaderExecutable9(IDirect3DPixelShader9 *executable, gl::D3DConstantTable *constantTable)
+ShaderExecutable9::ShaderExecutable9(const void *function, size_t length, IDirect3DPixelShader9 *executable, gl::D3DConstantTable *constantTable)
+    : ShaderExecutable(function, length)
 {
     mPixelExecutable = executable;
     mVertexExecutable = NULL;
     mConstantTable = constantTable;
 }
 
-ShaderExecutable9::ShaderExecutable9(IDirect3DVertexShader9 *executable, gl::D3DConstantTable *constantTable)
+ShaderExecutable9::ShaderExecutable9(const void *function, size_t length, IDirect3DVertexShader9 *executable, gl::D3DConstantTable *constantTable)
+    : ShaderExecutable(function, length)
 {
     mVertexExecutable = executable;
     mPixelExecutable = NULL;
@@ -48,26 +50,6 @@ ShaderExecutable9 *ShaderExecutable9::makeShaderExecutable9(ShaderExecutable *ex
     return static_cast<ShaderExecutable9*>(executable);
 }
 
-bool ShaderExecutable9::getVertexFunction(void *pData, UINT *pSizeOfData)
-{
-    HRESULT hr = D3DERR_INVALIDCALL;
-    if (mVertexExecutable)
-    {
-        hr = mVertexExecutable->GetFunction(pData, pSizeOfData);
-    }
-    return SUCCEEDED(hr);
-}
-
-bool ShaderExecutable9::getPixelFunction(void *pData, UINT *pSizeOfData)
-{
-    HRESULT hr = D3DERR_INVALIDCALL;
-    if (mPixelExecutable)
-    {
-        hr = mPixelExecutable->GetFunction(pData, pSizeOfData);
-    }
-    return SUCCEEDED(hr);
-}
-
 IDirect3DVertexShader9 *ShaderExecutable9::getVertexShader()
 {
     return mVertexExecutable;

src/libGLESv2/renderer/ShaderExecutable9.h

@@ -21,13 +21,10 @@ namespace rx
 class ShaderExecutable9 : public ShaderExecutable
 {
   public:
-    ShaderExecutable9(IDirect3DPixelShader9 *executable, gl::D3DConstantTable *constantTable);
-    ShaderExecutable9(IDirect3DVertexShader9 *executable, gl::D3DConstantTable *constantTable);
+    ShaderExecutable9(const void *function, size_t length, IDirect3DPixelShader9 *executable, gl::D3DConstantTable *constantTable);
+    ShaderExecutable9(const void *function, size_t length, IDirect3DVertexShader9 *executable, gl::D3DConstantTable *constantTable);
     virtual ~ShaderExecutable9();
 
-    virtual bool getVertexFunction(void *pData, UINT *pSizeOfData);
-    virtual bool getPixelFunction(void *pData, UINT *pSizeOfData);
-
     static ShaderExecutable9 *makeShaderExecutable9(ShaderExecutable *executable);
 
     IDirect3DPixelShader9 *getPixelShader();