D3D11: Consolidate Shader allocation.

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -195,7 +195,7 @@ class RendererD3D : public BufferFactoryD3D
     virtual gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) = 0;
 
     // Shader operations
-    virtual gl::Error loadExecutable(const void *function,
+    virtual gl::Error loadExecutable(const uint8_t *function,
                                      size_t length,
                                      ShaderType type,
                                      const std::vector<D3DVarying> &streamOutVaryings,

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

@@ -182,7 +182,7 @@ class Blit11 : angle::NonCopyable
     struct Shader
     {
         ShaderDimension dimension;
-        ID3D11PixelShader *pixelShader;
+        d3d11::PixelShader pixelShader;
     };
 
     struct ShaderSupport
@@ -247,9 +247,10 @@ class Blit11 : angle::NonCopyable
                              size_t destPixelStride,
                              BlitConvertFunction *convertFunction);
 
-    void addBlitShaderToMap(BlitShaderType blitShaderType,
-                            ShaderDimension dimension,
-                            ID3D11PixelShader *ps);
+    gl::Error addBlitShaderToMap(BlitShaderType blitShaderType,
+                                 ShaderDimension dimension,
+                                 const ShaderData &shaderData,
+                                 const char *name);
 
     gl::Error getBlitShader(GLenum destFormat,
                             GLenum sourceFormat,
@@ -262,9 +263,10 @@ class Blit11 : angle::NonCopyable
                                D3D11_SRV_DIMENSION viewDimension,
                                const Shader **shaderOut);
 
-    void addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType,
-                               ShaderDimension dimension,
-                               ID3D11PixelShader *ps);
+    gl::Error addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType,
+                                    ShaderDimension dimension,
+                                    const ShaderData &shaderData,
+                                    const char *name);
 
     void clearShaderMap();
     void releaseResolveDepthStencilResources();

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

@@ -94,12 +94,6 @@ Clear11::ShaderManager::ShaderManager()
 
 Clear11::ShaderManager::~ShaderManager()
 {
-    mVs9.release();
-    mPsFloat9.release();
-    mVs.release();
-    mPsFloat.release();
-    mPsUInt.release();
-    mPsSInt.release();
 }
 
 gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
@@ -108,14 +102,12 @@ gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
                                                       ID3D11VertexShader **vs,
                                                       ID3D11PixelShader **ps)
 {
-    auto featureLevel = renderer->getRenderer11DeviceCaps().featureLevel;
-    auto device       = renderer->getDevice();
-
-    if (featureLevel <= D3D_FEATURE_LEVEL_9_3)
+    if (renderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
     {
         ASSERT(clearType == GL_FLOAT);
 
-        *vs = mVs9.resolve(device);
+        ANGLE_TRY(mVs9.resolve(renderer));
+        ANGLE_TRY(mPsFloat9.resolve(renderer));
 
         if (!mIl9.valid())
         {
@@ -128,24 +120,29 @@ gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
             ANGLE_TRY(renderer->allocateResource(ilDescArray, &vertexShader, &mIl9));
         }
 
+        *vs = mVs9.get();
         *il = mIl9.get();
-        *ps = mPsFloat9.resolve(device);
+        *ps = mPsFloat9.get();
         return gl::NoError();
     }
 
-    *vs = mVs.resolve(device);
+    ANGLE_TRY(mVs.resolve(renderer));
+    *vs = mVs.get();
     *il = nullptr;
 
     switch (clearType)
     {
         case GL_FLOAT:
-            *ps = mPsFloat.resolve(device);
+            ANGLE_TRY(mPsFloat.resolve(renderer));
+            *ps = mPsFloat.get();
             break;
         case GL_UNSIGNED_INT:
-            *ps = mPsUInt.resolve(device);
+            ANGLE_TRY(mPsUInt.resolve(renderer));
+            *ps = mPsUInt.get();
             break;
         case GL_INT:
-            *ps = mPsSInt.resolve(device);
+            ANGLE_TRY(mPsSInt.resolve(renderer));
+            *ps = mPsSInt.get();
             break;
         default:
             UNREACHABLE();

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

@@ -36,8 +36,8 @@ namespace rx
 PixelTransfer11::PixelTransfer11(Renderer11 *renderer)
     : mRenderer(renderer),
       mResourcesLoaded(false),
-      mBufferToTextureVS(nullptr),
-      mBufferToTextureGS(nullptr),
+      mBufferToTextureVS(),
+      mBufferToTextureGS(),
       mParamsConstantBuffer(),
       mCopyRasterizerState(),
       mCopyDepthStencilState()
@@ -46,15 +46,6 @@ PixelTransfer11::PixelTransfer11(Renderer11 *renderer)
 
 PixelTransfer11::~PixelTransfer11()
 {
-    for (auto shaderMapIt = mBufferToTexturePSMap.begin(); shaderMapIt != mBufferToTexturePSMap.end(); shaderMapIt++)
-    {
-        SafeRelease(shaderMapIt->second);
-    }
-
-    mBufferToTexturePSMap.clear();
-
-    SafeRelease(mBufferToTextureVS);
-    SafeRelease(mBufferToTextureGS);
 }
 
 gl::Error PixelTransfer11::loadResources()
@@ -108,18 +99,11 @@ gl::Error PixelTransfer11::loadResources()
     mParamsConstantBuffer.setDebugName("PixelTransfer11 constant buffer");
 
     // init shaders
-    ID3D11Device *device = mRenderer->getDevice();
-    mBufferToTextureVS = d3d11::CompileVS(device, g_VS_BufferToTexture, "BufferToTexture VS");
-    if (!mBufferToTextureVS)
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer to texture vertex shader.");
-    }
+    ANGLE_TRY(mRenderer->allocateResource(ShaderData(g_VS_BufferToTexture), &mBufferToTextureVS));
+    mBufferToTextureVS.setDebugName("BufferToTexture VS");
 
-    mBufferToTextureGS = d3d11::CompileGS(device, g_GS_BufferToTexture, "BufferToTexture GS");
-    if (!mBufferToTextureGS)
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer to texture geometry shader.");
-    }
+    ANGLE_TRY(mRenderer->allocateResource(ShaderData(g_GS_BufferToTexture), &mBufferToTextureGS));
+    mBufferToTextureGS.setDebugName("BufferToTexture GS");
 
     ANGLE_TRY(buildShaderMap());
 
@@ -200,10 +184,11 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
     UINT zero = 0;
 
     // Are we doing a 2D or 3D copy?
-    ID3D11GeometryShader *geometryShader = ((destSize.depth > 1) ? mBufferToTextureGS : nullptr);
+    ID3D11GeometryShader *geometryShader =
+        ((destSize.depth > 1) ? mBufferToTextureGS.get() : nullptr);
     auto stateManager                    = mRenderer->getStateManager();
 
-    deviceContext->VSSetShader(mBufferToTextureVS, nullptr, 0);
+    deviceContext->VSSetShader(mBufferToTextureVS.get(), nullptr, 0);
     deviceContext->GSSetShader(geometryShader, nullptr, 0);
     deviceContext->PSSetShader(pixelShader, nullptr, 0);
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, bufferSRV);
@@ -250,20 +235,24 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
 
 gl::Error PixelTransfer11::buildShaderMap()
 {
-    ID3D11Device *device = mRenderer->getDevice();
+    d3d11::PixelShader bufferToTextureFloat;
+    d3d11::PixelShader bufferToTextureInt;
+    d3d11::PixelShader bufferToTextureUint;
 
-    mBufferToTexturePSMap[GL_FLOAT]        = d3d11::CompilePS(device, g_PS_BufferToTexture_4F,  "BufferToTexture RGBA ps");
-    mBufferToTexturePSMap[GL_INT]          = d3d11::CompilePS(device, g_PS_BufferToTexture_4I,  "BufferToTexture RGBA-I ps");
-    mBufferToTexturePSMap[GL_UNSIGNED_INT] = d3d11::CompilePS(device, g_PS_BufferToTexture_4UI, "BufferToTexture RGBA-UI ps");
+    ANGLE_TRY(
+        mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4F), &bufferToTextureFloat));
+    ANGLE_TRY(
+        mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4I), &bufferToTextureInt));
+    ANGLE_TRY(
+        mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4UI), &bufferToTextureUint));
 
-    // Check that all the shaders were created successfully
-    for (auto shaderMapIt = mBufferToTexturePSMap.begin(); shaderMapIt != mBufferToTexturePSMap.end(); shaderMapIt++)
-    {
-        if (shaderMapIt->second == nullptr)
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer to texture pixel shader.");
-        }
-    }
+    bufferToTextureFloat.setDebugName("BufferToTexture RGBA ps");
+    bufferToTextureInt.setDebugName("BufferToTexture RGBA-I ps");
+    bufferToTextureUint.setDebugName("BufferToTexture RGBA-UI ps");
+
+    mBufferToTexturePSMap[GL_FLOAT]        = std::move(bufferToTextureFloat);
+    mBufferToTexturePSMap[GL_INT]          = std::move(bufferToTextureInt);
+    mBufferToTexturePSMap[GL_UNSIGNED_INT] = std::move(bufferToTextureUint);
 
     return gl::NoError();
 }
@@ -277,7 +266,7 @@ ID3D11PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat)
     }
 
     auto shaderMapIt = mBufferToTexturePSMap.find(componentType);
-    return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : shaderMapIt->second);
+    return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : shaderMapIt->second.get());
 }
 
 }  // namespace rx

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

@@ -73,9 +73,9 @@ class PixelTransfer11
     Renderer11 *mRenderer;
 
     bool mResourcesLoaded;
-    std::map<GLenum, ID3D11PixelShader *> mBufferToTexturePSMap;
-    ID3D11VertexShader *mBufferToTextureVS;
-    ID3D11GeometryShader *mBufferToTextureGS;
+    std::map<GLenum, d3d11::PixelShader> mBufferToTexturePSMap;
+    d3d11::VertexShader mBufferToTextureVS;
+    d3d11::GeometryShader mBufferToTextureGS;
     d3d11::Buffer mParamsConstantBuffer;
     CopyShaderParams mParamsData;
 

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

@@ -3647,26 +3647,22 @@ gl::Error Renderer11::createRenderTargetCopy(RenderTargetD3D *source, RenderTarg
     return gl::NoError();
 }
 
-gl::Error Renderer11::loadExecutable(const void *function,
+gl::Error Renderer11::loadExecutable(const uint8_t *function,
                                      size_t length,
                                      ShaderType type,
                                      const std::vector<D3DVarying> &streamOutVaryings,
                                      bool separatedOutputBuffers,
                                      ShaderExecutableD3D **outExecutable)
 {
+    ShaderData shaderData(function, length);
+
     switch (type)
     {
         case SHADER_VERTEX:
         {
-            ID3D11VertexShader *vertexShader      = nullptr;
-            ID3D11GeometryShader *streamOutShader = nullptr;
-
-            HRESULT result = mDevice->CreateVertexShader(function, length, nullptr, &vertexShader);
-            ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to create vertex shader, " << result;
-            }
+            d3d11::VertexShader vertexShader;
+            d3d11::GeometryShader streamOutShader;
+            ANGLE_TRY(allocateResource(shaderData, &vertexShader));
 
             if (!streamOutVaryings.empty())
             {
@@ -3686,63 +3682,32 @@ gl::Error Renderer11::loadExecutable(const void *function,
                     soDeclaration.push_back(entry);
                 }
 
-                result = mDevice->CreateGeometryShaderWithStreamOutput(
-                    function, static_cast<unsigned int>(length), soDeclaration.data(),
-                    static_cast<unsigned int>(soDeclaration.size()), nullptr, 0, 0, nullptr,
-                    &streamOutShader);
-                ASSERT(SUCCEEDED(result));
-                if (FAILED(result))
-                {
-                    return gl::OutOfMemory() << "Failed to create steam output shader, " << result;
-                }
+                ANGLE_TRY(allocateResource(shaderData, &soDeclaration, &streamOutShader));
             }
 
-            *outExecutable =
-                new ShaderExecutable11(function, length, vertexShader, streamOutShader);
+            *outExecutable = new ShaderExecutable11(function, length, std::move(vertexShader),
+                                                    std::move(streamOutShader));
         }
         break;
         case SHADER_PIXEL:
         {
-            ID3D11PixelShader *pixelShader = nullptr;
-
-            HRESULT result = mDevice->CreatePixelShader(function, length, nullptr, &pixelShader);
-            ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to create pixel shader, " << result;
-            }
-
-            *outExecutable = new ShaderExecutable11(function, length, pixelShader);
+            d3d11::PixelShader pixelShader;
+            ANGLE_TRY(allocateResource(shaderData, &pixelShader));
+            *outExecutable = new ShaderExecutable11(function, length, std::move(pixelShader));
         }
         break;
         case SHADER_GEOMETRY:
         {
-            ID3D11GeometryShader *geometryShader = nullptr;
-
-            HRESULT result =
-                mDevice->CreateGeometryShader(function, length, nullptr, &geometryShader);
-            ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to create geometry shader, " << result;
-            }
-
-            *outExecutable = new ShaderExecutable11(function, length, geometryShader);
+            d3d11::GeometryShader geometryShader;
+            ANGLE_TRY(allocateResource(shaderData, &geometryShader));
+            *outExecutable = new ShaderExecutable11(function, length, std::move(geometryShader));
         }
         break;
         case SHADER_COMPUTE:
         {
-            ID3D11ComputeShader *computeShader = nullptr;
-
-            HRESULT result =
-                mDevice->CreateComputeShader(function, length, nullptr, &computeShader);
-            ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to create compute shader, " << result;
-            }
-
-            *outExecutable = new ShaderExecutable11(function, length, computeShader);
+            d3d11::ComputeShader computeShader;
+            ANGLE_TRY(allocateResource(shaderData, &computeShader));
+            *outExecutable = new ShaderExecutable11(function, length, std::move(computeShader));
         }
         break;
         default:
@@ -3819,6 +3784,7 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
 
     D3D_SHADER_MACRO loopMacros[] = {{"ANGLE_ENABLE_LOOP_FLATTEN", "1"}, {0, 0}};
 
+    // TODO(jmadill): Use ComPtr?
     ID3DBlob *binary = nullptr;
     std::string debugInfo;
     ANGLE_TRY(mCompiler.compileToBinary(infoLog, shaderHLSL, profile, configs, loopMacros, &binary,
@@ -3833,8 +3799,9 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
         return gl::NoError();
     }
 
-    gl::Error error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
-                                     streamOutVaryings, separatedOutputBuffers, outExectuable);
+    gl::Error error = loadExecutable(reinterpret_cast<const uint8_t *>(binary->GetBufferPointer()),
+                                     binary->GetBufferSize(), type, streamOutVaryings,
+                                     separatedOutputBuffers, outExectuable);
 
     SafeRelease(binary);
     if (error.isError())

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

@@ -240,7 +240,7 @@ class Renderer11 : public RendererD3D
     gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) override;
 
     // Shader operations
-    gl::Error loadExecutable(const void *function,
+    gl::Error loadExecutable(const uint8_t *function,
                              size_t length,
                              ShaderType type,
                              const std::vector<D3DVarying> &streamOutVaryings,

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

@@ -105,6 +105,14 @@ HRESULT CreateResource(ID3D11Device *device,
 }
 
 HRESULT CreateResource(ID3D11Device *device,
+                       const ShaderData *desc,
+                       void * /*initData*/,
+                       ID3D11ComputeShader **resourceOut)
+{
+    return device->CreateComputeShader(desc->get(), desc->size(), nullptr, resourceOut);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
                        const D3D11_DEPTH_STENCIL_DESC *desc,
                        void * /*initData*/,
                        ID3D11DepthStencilState **resourceOut)
@@ -121,6 +129,23 @@ HRESULT CreateResource(ID3D11Device *device,
 }
 
 HRESULT CreateResource(ID3D11Device *device,
+                       const ShaderData *desc,
+                       const std::vector<D3D11_SO_DECLARATION_ENTRY> *initData,
+                       ID3D11GeometryShader **resourceOut)
+{
+    if (initData)
+    {
+        return device->CreateGeometryShaderWithStreamOutput(
+            desc->get(), desc->size(), initData->data(), static_cast<UINT>(initData->size()),
+            nullptr, 0, 0, nullptr, resourceOut);
+    }
+    else
+    {
+        return device->CreateGeometryShader(desc->get(), desc->size(), nullptr, resourceOut);
+    }
+}
+
+HRESULT CreateResource(ID3D11Device *device,
                        const InputElementArray *desc,
                        const ShaderData *initData,
                        ID3D11InputLayout **resourceOut)
@@ -130,6 +155,14 @@ HRESULT CreateResource(ID3D11Device *device,
 }
 
 HRESULT CreateResource(ID3D11Device *device,
+                       const ShaderData *desc,
+                       void * /*initData*/,
+                       ID3D11PixelShader **resourceOut)
+{
+    return device->CreatePixelShader(desc->get(), desc->size(), nullptr, resourceOut);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
                        const D3D11_RASTERIZER_DESC *desc,
                        void * /*initData*/,
                        ID3D11RasterizerState **rasterizerState)
@@ -177,6 +210,14 @@ HRESULT CreateResource(ID3D11Device *device,
     return device->CreateTexture3D(desc, initData, texture);
 }
 
+HRESULT CreateResource(ID3D11Device *device,
+                       const ShaderData *desc,
+                       void * /*initData*/,
+                       ID3D11VertexShader **resourceOut)
+{
+    return device->CreateVertexShader(desc->get(), desc->size(), nullptr, resourceOut);
+}
+
 DXGI_FORMAT GetTypedDepthStencilFormat(DXGI_FORMAT dxgiFormat)
 {
     switch (dxgiFormat)

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

@@ -32,10 +32,14 @@ using ShaderData        = WrappedArray<uint8_t>;
 #define ANGLE_RESOURCE_TYPE_OP(NAME, OP)                                                     \
     OP(NAME, BlendState, ID3D11BlendState, D3D11_BLEND_DESC, void)                           \
     OP(NAME, Buffer, ID3D11Buffer, D3D11_BUFFER_DESC, const D3D11_SUBRESOURCE_DATA)          \
+    OP(NAME, ComputeShader, ID3D11ComputeShader, ShaderData, void)                           \
     OP(NAME, DepthStencilState, ID3D11DepthStencilState, D3D11_DEPTH_STENCIL_DESC, void)     \
     OP(NAME, DepthStencilView, ID3D11DepthStencilView, D3D11_DEPTH_STENCIL_VIEW_DESC,        \
        ID3D11Resource)                                                                       \
+    OP(NAME, GeometryShader, ID3D11GeometryShader, ShaderData,                               \
+       const std::vector<D3D11_SO_DECLARATION_ENTRY>)                                        \
     OP(NAME, InputLayout, ID3D11InputLayout, InputElementArray, const ShaderData)            \
+    OP(NAME, PixelShader, ID3D11PixelShader, ShaderData, void)                               \
     OP(NAME, RasterizerState, ID3D11RasterizerState, D3D11_RASTERIZER_DESC, void)            \
     OP(NAME, RenderTargetView, ID3D11RenderTargetView, D3D11_RENDER_TARGET_VIEW_DESC,        \
        ID3D11Resource)                                                                       \
@@ -43,7 +47,8 @@ using ShaderData        = WrappedArray<uint8_t>;
     OP(NAME, ShaderResourceView, ID3D11ShaderResourceView, D3D11_SHADER_RESOURCE_VIEW_DESC,  \
        ID3D11Resource)                                                                       \
     OP(NAME, Texture2D, ID3D11Texture2D, D3D11_TEXTURE2D_DESC, const D3D11_SUBRESOURCE_DATA) \
-    OP(NAME, Texture3D, ID3D11Texture3D, D3D11_TEXTURE3D_DESC, const D3D11_SUBRESOURCE_DATA)
+    OP(NAME, Texture3D, ID3D11Texture3D, D3D11_TEXTURE3D_DESC, const D3D11_SUBRESOURCE_DATA) \
+    OP(NAME, VertexShader, ID3D11VertexShader, ShaderData, void)
 
 #define ANGLE_RESOURCE_TYPE_LIST(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) RESTYPE,
 

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

@@ -13,80 +13,82 @@
 namespace rx
 {
 
-ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11PixelShader *executable)
-    : ShaderExecutableD3D(function, length)
+ShaderExecutable11::ShaderExecutable11(const void *function,
+                                       size_t length,
+                                       d3d11::PixelShader &&executable)
+    : ShaderExecutableD3D(function, length),
+      mPixelExecutable(std::move(executable)),
+      mVertexExecutable(),
+      mGeometryExecutable(),
+      mStreamOutExecutable(),
+      mComputeExecutable()
 {
-    mPixelExecutable = executable;
-    mVertexExecutable    = nullptr;
-    mGeometryExecutable  = nullptr;
-    mStreamOutExecutable = nullptr;
-    mComputeExecutable   = nullptr;
 }
 
-ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable, ID3D11GeometryShader *streamOut)
-    : ShaderExecutableD3D(function, length)
+ShaderExecutable11::ShaderExecutable11(const void *function,
+                                       size_t length,
+                                       d3d11::VertexShader &&executable,
+                                       d3d11::GeometryShader &&streamOut)
+    : ShaderExecutableD3D(function, length),
+      mPixelExecutable(),
+      mVertexExecutable(std::move(executable)),
+      mGeometryExecutable(),
+      mStreamOutExecutable(std::move(streamOut)),
+      mComputeExecutable()
 {
-    mVertexExecutable = executable;
-    mPixelExecutable     = nullptr;
-    mGeometryExecutable  = nullptr;
-    mStreamOutExecutable = streamOut;
-    mComputeExecutable   = nullptr;
 }
 
-ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11GeometryShader *executable)
-    : ShaderExecutableD3D(function, length)
+ShaderExecutable11::ShaderExecutable11(const void *function,
+                                       size_t length,
+                                       d3d11::GeometryShader &&executable)
+    : ShaderExecutableD3D(function, length),
+      mPixelExecutable(),
+      mVertexExecutable(),
+      mGeometryExecutable(std::move(executable)),
+      mStreamOutExecutable(),
+      mComputeExecutable()
 {
-    mGeometryExecutable = executable;
-    mVertexExecutable    = nullptr;
-    mPixelExecutable     = nullptr;
-    mStreamOutExecutable = nullptr;
-    mComputeExecutable   = nullptr;
 }
 
 ShaderExecutable11::ShaderExecutable11(const void *function,
                                        size_t length,
-                                       ID3D11ComputeShader *executable)
-    : ShaderExecutableD3D(function, length)
+                                       d3d11::ComputeShader &&executable)
+    : ShaderExecutableD3D(function, length),
+      mPixelExecutable(),
+      mVertexExecutable(),
+      mGeometryExecutable(),
+      mStreamOutExecutable(),
+      mComputeExecutable(std::move(executable))
 {
-    mComputeExecutable   = executable;
-    mPixelExecutable     = nullptr;
-    mVertexExecutable    = nullptr;
-    mGeometryExecutable  = nullptr;
-    mStreamOutExecutable = nullptr;
 }
 
 ShaderExecutable11::~ShaderExecutable11()
 {
-    SafeRelease(mVertexExecutable);
-    SafeRelease(mPixelExecutable);
-    SafeRelease(mGeometryExecutable);
-    SafeRelease(mStreamOutExecutable);
-    SafeRelease(mComputeExecutable);
 }
 
 ID3D11VertexShader *ShaderExecutable11::getVertexShader() const
 {
-    return mVertexExecutable;
+    return mVertexExecutable.get();
 }
 
 ID3D11PixelShader *ShaderExecutable11::getPixelShader() const
 {
-    return mPixelExecutable;
+    return mPixelExecutable.get();
 }
 
 ID3D11GeometryShader *ShaderExecutable11::getGeometryShader() const
 {
-    return mGeometryExecutable;
+    return mGeometryExecutable.get();
 }
 
 ID3D11GeometryShader *ShaderExecutable11::getStreamOutShader() const
 {
-    return mStreamOutExecutable;
+    return mStreamOutExecutable.get();
 }
 
 ID3D11ComputeShader *ShaderExecutable11::getComputeShader() const
 {
-    return mComputeExecutable;
+    return mComputeExecutable.get();
 }
 
 UniformStorage11::UniformStorage11(size_t initialSize)

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

@@ -21,10 +21,13 @@ class UniformStorage11;
 class ShaderExecutable11 : public ShaderExecutableD3D
 {
   public:
-    ShaderExecutable11(const void *function, size_t length, ID3D11PixelShader *executable);
-    ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable, ID3D11GeometryShader *streamOut);
-    ShaderExecutable11(const void *function, size_t length, ID3D11GeometryShader *executable);
-    ShaderExecutable11(const void *function, size_t length, ID3D11ComputeShader *executable);
+    ShaderExecutable11(const void *function, size_t length, d3d11::PixelShader &&executable);
+    ShaderExecutable11(const void *function,
+                       size_t length,
+                       d3d11::VertexShader &&executable,
+                       d3d11::GeometryShader &&streamOut);
+    ShaderExecutable11(const void *function, size_t length, d3d11::GeometryShader &&executable);
+    ShaderExecutable11(const void *function, size_t length, d3d11::ComputeShader &&executable);
 
     virtual ~ShaderExecutable11();
 
@@ -35,11 +38,11 @@ class ShaderExecutable11 : public ShaderExecutableD3D
     ID3D11ComputeShader *getComputeShader() const;
 
   private:
-    ID3D11PixelShader *mPixelExecutable;
-    ID3D11VertexShader *mVertexExecutable;
-    ID3D11GeometryShader *mGeometryExecutable;
-    ID3D11GeometryShader *mStreamOutExecutable;
-    ID3D11ComputeShader *mComputeExecutable;
+    d3d11::PixelShader mPixelExecutable;
+    d3d11::VertexShader mVertexExecutable;
+    d3d11::GeometryShader mGeometryExecutable;
+    d3d11::GeometryShader mStreamOutExecutable;
+    d3d11::ComputeShader mComputeExecutable;
 };
 
 class UniformStorage11 : public UniformStorageD3D

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

@@ -83,8 +83,8 @@ SwapChain11::SwapChain11(Renderer11 *renderer,
       mQuadVB(),
       mPassThroughSampler(),
       mPassThroughIL(),
-      mPassThroughVS(nullptr),
-      mPassThroughPS(nullptr),
+      mPassThroughVS(),
+      mPassThroughPS(),
       mPassThroughRS(),
       mColorRenderTarget(this, renderer, false),
       mDepthStencilRenderTarget(this, renderer, true),
@@ -123,8 +123,8 @@ void SwapChain11::release()
     mQuadVB.reset();
     mPassThroughSampler.reset();
     mPassThroughIL.reset();
-    SafeRelease(mPassThroughVS);
-    SafeRelease(mPassThroughPS);
+    mPassThroughVS.reset();
+    mPassThroughPS.reset();
     mPassThroughRS.reset();
 
     if (!mAppCreatedShareHandle)
@@ -612,7 +612,7 @@ void SwapChain11::initPassThroughResources()
 
     // Make sure our resources are all not allocated, when we create
     ASSERT(!mQuadVB.valid() && !mPassThroughSampler.valid());
-    ASSERT(!mPassThroughIL.valid() && mPassThroughVS == nullptr && mPassThroughPS == nullptr);
+    ASSERT(!mPassThroughIL.valid() && !mPassThroughVS.valid() && !mPassThroughPS.valid());
 
     D3D11_BUFFER_DESC vbDesc;
     vbDesc.ByteWidth = sizeof(d3d11::PositionTexCoordVertex) * 4;
@@ -658,24 +658,23 @@ void SwapChain11::initPassThroughResources()
     ASSERT(!err.isError());
     mPassThroughIL.setDebugName("Swap chain pass through layout");
 
-    HRESULT result = device->CreateVertexShader(g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D),
-                                                nullptr, &mPassThroughVS);
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mPassThroughVS, "Swap chain pass through vertex shader");
+    err = mRenderer->allocateResource(vertexShaderData, &mPassThroughVS);
+    ASSERT(!err.isError());
+    mPassThroughVS.setDebugName("Swap chain pass through vertex shader");
 
     if (mEGLSamples <= 1)
     {
-        result = device->CreatePixelShader(g_PS_PassthroughRGBA2D, sizeof(g_PS_PassthroughRGBA2D),
-                                           nullptr, &mPassThroughPS);
+        ShaderData pixelShaderData(g_PS_PassthroughRGBA2D);
+        err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
     }
     else
     {
-        result = device->CreatePixelShader(
-            g_PS_PassthroughRGBA2DMS, sizeof(g_PS_PassthroughRGBA2DMS), nullptr, &mPassThroughPS);
+        ShaderData pixelShaderData(g_PS_PassthroughRGBA2DMS);
+        err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
     }
 
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mPassThroughPS, "Swap chain pass through pixel shader");
+    ASSERT(!err.isError());
+    mPassThroughPS.setDebugName("Swap chain pass through pixel shader");
 
     // Use the default rasterizer state but without culling
     D3D11_RASTERIZER_DESC rasterizerDesc;
@@ -786,8 +785,8 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
     // Apply shaders
     deviceContext->IASetInputLayout(mPassThroughIL.get());
     deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
-    deviceContext->VSSetShader(mPassThroughVS, nullptr, 0);
-    deviceContext->PSSetShader(mPassThroughPS, nullptr, 0);
+    deviceContext->VSSetShader(mPassThroughVS.get(), nullptr, 0);
+    deviceContext->PSSetShader(mPassThroughPS.get(), nullptr, 0);
     deviceContext->GSSetShader(nullptr, nullptr, 0);
 
     auto stateManager = mRenderer->getStateManager();

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

@@ -101,8 +101,8 @@ class SwapChain11 final : public SwapChainD3D
     d3d11::Buffer mQuadVB;
     d3d11::SamplerState mPassThroughSampler;
     d3d11::InputLayout mPassThroughIL;
-    ID3D11VertexShader *mPassThroughVS;
-    ID3D11PixelShader *mPassThroughPS;
+    d3d11::VertexShader mPassThroughVS;
+    d3d11::PixelShader mPassThroughPS;
     d3d11::RasterizerState mPassThroughRS;
 
     SurfaceRenderTarget11 mColorRenderTarget;

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

@@ -184,86 +184,12 @@ inline bool isDeviceLostError(HRESULT errorCode)
     }
 }
 
-inline ID3D11VertexShader *CompileVS(ID3D11Device *device, const BYTE *byteCode, size_t N, const char *name)
-{
-    ID3D11VertexShader *vs = nullptr;
-    HRESULT result = device->CreateVertexShader(byteCode, N, nullptr, &vs);
-    ASSERT(SUCCEEDED(result));
-    if (SUCCEEDED(result))
-    {
-        SetDebugName(vs, name);
-        return vs;
-    }
-    return nullptr;
-}
-
-template <unsigned int N>
-ID3D11VertexShader *CompileVS(ID3D11Device *device, const BYTE (&byteCode)[N], const char *name)
-{
-    return CompileVS(device, byteCode, N, name);
-}
-
-inline ID3D11GeometryShader *CompileGS(ID3D11Device *device, const BYTE *byteCode, size_t N, const char *name)
-{
-    ID3D11GeometryShader *gs = nullptr;
-    HRESULT result = device->CreateGeometryShader(byteCode, N, nullptr, &gs);
-    ASSERT(SUCCEEDED(result));
-    if (SUCCEEDED(result))
-    {
-        SetDebugName(gs, name);
-        return gs;
-    }
-    return nullptr;
-}
-
-template <unsigned int N>
-ID3D11GeometryShader *CompileGS(ID3D11Device *device, const BYTE (&byteCode)[N], const char *name)
-{
-    return CompileGS(device, byteCode, N, name);
-}
-
-inline ID3D11PixelShader *CompilePS(ID3D11Device *device, const BYTE *byteCode, size_t N, const char *name)
-{
-    ID3D11PixelShader *ps = nullptr;
-    HRESULT result = device->CreatePixelShader(byteCode, N, nullptr, &ps);
-    ASSERT(SUCCEEDED(result));
-    if (SUCCEEDED(result))
-    {
-        SetDebugName(ps, name);
-        return ps;
-    }
-    return nullptr;
-}
-
-template <unsigned int N>
-ID3D11PixelShader *CompilePS(ID3D11Device *device, const BYTE (&byteCode)[N], const char *name)
-{
-    return CompilePS(device, byteCode, N, name);
-}
-
-template <typename ResourceType>
-class LazyResource : angle::NonCopyable
-{
-  public:
-    LazyResource() : mResource(nullptr), mAssociatedDevice(nullptr) {}
-    virtual ~LazyResource() { release(); }
-
-    virtual ResourceType *resolve(ID3D11Device *device) = 0;
-    void release() { SafeRelease(mResource); }
-
-  protected:
-    void checkAssociatedDevice(ID3D11Device *device);
-
-    ResourceType *mResource;
-    ID3D11Device *mAssociatedDevice;
-};
-
 template <ResourceType ResourceT>
-class LazyResource2 : angle::NonCopyable
+class LazyResource : angle::NonCopyable
 {
   public:
-    constexpr LazyResource2() : mResource() {}
-    virtual ~LazyResource2() {}
+    constexpr LazyResource() : mResource() {}
+    virtual ~LazyResource() {}
 
     virtual gl::Error resolve(Renderer11 *renderer) = 0;
     void reset() { mResource.reset(); }
@@ -290,69 +216,27 @@ class LazyResource2 : angle::NonCopyable
     Resource11<GetD3D11Type<ResourceT>> mResource;
 };
 
-template <typename ResourceType>
-void LazyResource<ResourceType>::checkAssociatedDevice(ID3D11Device *device)
-{
-    ASSERT(mAssociatedDevice == nullptr || device == mAssociatedDevice);
-    mAssociatedDevice = device;
-}
-
 template <typename D3D11ShaderType>
-class LazyShader final : public LazyResource<D3D11ShaderType>
+class LazyShader final : public LazyResource<GetResourceTypeFromD3D11<D3D11ShaderType>()>
 {
   public:
     // All parameters must be constexpr. Not supported in VS2013.
-    LazyShader(const BYTE *byteCode,
-               size_t byteCodeSize,
-               const char *name)
-        : mByteCode(byteCode),
-          mByteCodeSize(byteCodeSize),
-          mName(name)
+    constexpr LazyShader(const BYTE *byteCode, size_t byteCodeSize, const char *name)
+        : mByteCode(byteCode, byteCodeSize), mName(name)
     {
     }
 
-    D3D11ShaderType *resolve(ID3D11Device *device) override;
+    gl::Error resolve(Renderer11 *renderer) override
+    {
+        return this->resolveImpl(renderer, mByteCode, nullptr, mName);
+    }
 
   private:
-    const BYTE *mByteCode;
-    size_t mByteCodeSize;
+    ShaderData mByteCode;
     const char *mName;
 };
 
-template <>
-inline ID3D11VertexShader *LazyShader<ID3D11VertexShader>::resolve(ID3D11Device *device)
-{
-    checkAssociatedDevice(device);
-    if (mResource == nullptr)
-    {
-        mResource = CompileVS(device, mByteCode, mByteCodeSize, mName);
-    }
-    return mResource;
-}
-
-template <>
-inline ID3D11GeometryShader *LazyShader<ID3D11GeometryShader>::resolve(ID3D11Device *device)
-{
-    checkAssociatedDevice(device);
-    if (mResource == nullptr)
-    {
-        mResource = CompileGS(device, mByteCode, mByteCodeSize, mName);
-    }
-    return mResource;
-}
-
-template <>
-inline ID3D11PixelShader *LazyShader<ID3D11PixelShader>::resolve(ID3D11Device *device)
-{
-    checkAssociatedDevice(device);
-    if (mResource == nullptr)
-    {
-        mResource = CompilePS(device, mByteCode, mByteCodeSize, mName);
-    }
-    return mResource;
-}
-
-class LazyInputLayout final : public LazyResource2<ResourceType::InputLayout>
+class LazyInputLayout final : public LazyResource<ResourceType::InputLayout>
 {
   public:
     constexpr LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
@@ -374,7 +258,7 @@ class LazyInputLayout final : public LazyResource2<ResourceType::InputLayout>
     const char *mDebugName;
 };
 
-class LazyBlendState final : public LazyResource2<ResourceType::BlendState>
+class LazyBlendState final : public LazyResource<ResourceType::BlendState>
 {
   public:
     LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName);

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

@@ -2697,7 +2697,7 @@ gl::Error Renderer9::createRenderTargetCopy(RenderTargetD3D *source, RenderTarge
     return gl::NoError();
 }
 
-gl::Error Renderer9::loadExecutable(const void *function,
+gl::Error Renderer9::loadExecutable(const uint8_t *function,
                                     size_t length,
                                     ShaderType type,
                                     const std::vector<D3DVarying> &streamOutVaryings,
@@ -2817,8 +2817,9 @@ gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
         return gl::NoError();
     }
 
-    error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
-                           streamOutVaryings, separatedOutputBuffers, outExectuable);
+    error = loadExecutable(reinterpret_cast<const uint8_t *>(binary->GetBufferPointer()),
+                           binary->GetBufferSize(), type, streamOutVaryings, separatedOutputBuffers,
+                           outExectuable);
 
     SafeRelease(binary);
     if (error.isError())

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

@@ -244,7 +244,7 @@ class Renderer9 : public RendererD3D
     gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) override;
 
     // Shader operations
-    gl::Error loadExecutable(const void *function,
+    gl::Error loadExecutable(const uint8_t *function,
                              size_t length,
                              ShaderType type,
                              const std::vector<D3DVarying> &streamOutVaryings,