DXBCUtils::RemapResourceBindings: return byte code blob instead of patching it in place

TheMostDiligent · TheMostDiligent · commit b35e4fdbd381 · 2025-03-02T18:40:53.000-08:00
diff --git a/Graphics/GraphicsEngineD3D11/src/PipelineStateD3D11Impl.cpp b/Graphics/GraphicsEngineD3D11/src/PipelineStateD3D11Impl.cpp
@@ -141,8 +141,8 @@ void PipelineStateD3D11Impl::RemapOrVerifyShaderResources(const TShaderStages&
 
         if (HandleRemappedBytecodeFn)
         {
-            RefCntAutoPtr<IDataBlob> pPatchedBytecode = DataBlobImpl::MakeCopy(pBytecode);
-            if (!DXBCUtils::RemapResourceBindings(ResourceMap, pPatchedBytecode->GetDataPtr(), pPatchedBytecode->GetSize()))
+            RefCntAutoPtr<IDataBlob> pPatchedBytecode = DXBCUtils::RemapResourceBindings(ResourceMap, pBytecode->GetConstDataPtr(), pBytecode->GetSize());
+            if (!pPatchedBytecode)
                 LOG_ERROR_AND_THROW("Failed to remap resource bindings in shader '", pShader->GetDesc().Name, "'.");
 
             HandleRemappedBytecodeFn(s, pShader, pPatchedBytecode);
diff --git a/Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/PipelineStateD3D12Impl.cpp
@@ -491,8 +491,8 @@ void PipelineStateD3D12Impl::RemapOrVerifyShaderResources(TShaderStages&
                 }
                 else
                 {
-                    pBytecode = DataBlobImpl::MakeCopy(pBytecode);
-                    if (!DXBCUtils::RemapResourceBindings(ResourceMap, pBytecode->GetDataPtr(), pBytecode->GetSize()))
+                    pBytecode = DXBCUtils::RemapResourceBindings(ResourceMap, pBytecode->GetDataPtr(), pBytecode->GetSize());
+                    if (!pBytecode)
                         LOG_ERROR_AND_THROW("Failed to remap resource bindings in shader '", pShader->GetDesc().Name, "'.");
                 }
             }
diff --git a/Graphics/ShaderTools/include/DXBCUtils.hpp b/Graphics/ShaderTools/include/DXBCUtils.hpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -30,6 +30,8 @@
 #include "Constants.h"
 #include "Shader.h"
 #include "ResourceBindingMap.hpp"
+#include "DataBlob.h"
+#include "RefCntAutoPtr.hpp"
 
 namespace Diligent
 {
@@ -46,9 +48,9 @@ using TResourceBindingMap = ResourceBinding::TMap;
 /// \param [in]    ResourceMap - Resource binding map. For every resource in the
 ///                              byte code it must define the binding (shader register).
 /// \param [inout] pBytecode   - Byte code that will be patched.
-bool RemapResourceBindings(const TResourceBindingMap& ResourceMap,
-                           void*                      pBytecode,
-                           size_t                     Size);
+RefCntAutoPtr<IDataBlob> RemapResourceBindings(const TResourceBindingMap& ResourceMap,
+                                               const void*                pBytecode,
+                                               size_t                     Size);
 }; // namespace DXBCUtils
 
 } // namespace Diligent
diff --git a/Graphics/ShaderTools/src/DXBCUtils.cpp b/Graphics/ShaderTools/src/DXBCUtils.cpp
@@ -36,6 +36,7 @@
 
 #include "DXBCUtils.hpp"
 #include "../../../ThirdParty/GPUOpenShaderUtils/DXBCChecksum.h"
+#include "DataBlobImpl.hpp"
 
 namespace Diligent
 {
@@ -1700,37 +1701,34 @@ void ShaderBytecodeRemapper::PatchBytecode(Uint32* Token, const void* EndPtr) no
 namespace DXBCUtils
 {
 
-bool RemapResourceBindings(const TResourceBindingMap& ResourceMap,
-                           void*                      pBytecode,
-                           size_t                     Size)
+RefCntAutoPtr<IDataBlob> RemapResourceBindings(const TResourceBindingMap& ResourceMap,
+                                               const void*                pBytecode,
+                                               size_t                     Size)
 {
     if (pBytecode == nullptr)
     {
         LOG_ERROR_MESSAGE("pBytecode must not be null.");
-        return false;
+        return {};
     }
 
-    char* const       Ptr    = static_cast<char*>(pBytecode);
-    const void* const EndPtr = Ptr + Size;
-
     if (Size < sizeof(DXBCHeader))
     {
         LOG_ERROR_MESSAGE("The size of the byte code (", Size, ") is too small to contain the DXBC header. The byte code may be corrupted.");
-        return false;
+        return {};
     }
 
-    DXBCHeader& Header = *reinterpret_cast<DXBCHeader*>(Ptr);
+    const DXBCHeader& Header = *static_cast<const DXBCHeader*>(pBytecode);
     if (Header.TotalSize != Size)
     {
         LOG_ERROR_MESSAGE("The byte code size (", Header.TotalSize, ") specified in the header does not match the actual size (", Size,
                           "). The byte code may be corrupted.");
-        return false;
+        return {};
     }
 
 #ifdef DILIGENT_DEVELOPMENT
     {
         DWORD Checksum[4] = {};
-        CalculateDXBCChecksum(reinterpret_cast<BYTE*>(Ptr), static_cast<DWORD>(Size), Checksum);
+        CalculateDXBCChecksum(static_cast<const BYTE*>(pBytecode), static_cast<DWORD>(Size), Checksum);
 
         DEV_CHECK_ERR((Checksum[0] == Header.Checksum[0] &&
                        Checksum[1] == Header.Checksum[1] &&
@@ -1743,9 +1741,14 @@ bool RemapResourceBindings(const TResourceBindingMap& ResourceMap,
     if (Header.Magic != DXBCFourCC)
     {
         LOG_ERROR_MESSAGE("Bytecode header does not contain the 'DXBC' magic number. The byte code may be corrupted.");
-        return false;
+        return {};
     }
 
+    RefCntAutoPtr<IDataBlob> pRemappedBytecode = DataBlobImpl::Create(Size, pBytecode);
+
+    char* const       Ptr    = pRemappedBytecode->GetDataPtr<char>();
+    const void* const EndPtr = Ptr + Size;
+
     const Uint32*          Chunks = reinterpret_cast<Uint32*>(Ptr + sizeof(Header));
     ResourceBindingPerType BindingsPerType;
     TExtendedResourceMap   ExtResourceMap;
@@ -1760,12 +1763,12 @@ bool RemapResourceBindings(const TResourceBindingMap& ResourceMap,
             if (pChunk + 1 > EndPtr)
             {
                 LOG_ERROR_MESSAGE("Not enough space for the chunk header. The byte code may be corrupted.");
-                return false;
+                return {};
             }
             if ((Ptr + Chunks[i] + pChunk->Length) > EndPtr)
             {
                 LOG_ERROR_MESSAGE("Not enough space for the chunk data. The byte code may be corrupted.");
-                return false;
+                return {};
             }
 
             if (pChunk->Magic == RDEFFourCC)
@@ -1801,29 +1804,29 @@ bool RemapResourceBindings(const TResourceBindingMap& ResourceMap,
     }
     catch (...)
     {
-        return false;
+        return {};
     }
 
     if (!RemapResDef)
     {
         LOG_ERROR_MESSAGE("Failed to find 'RDEF' chunk with the resource definition.");
-        return false;
+        return {};
     }
 
     if (!RemapBytecode)
     {
         LOG_ERROR_MESSAGE("Failed to find 'SHDR' or 'SHEX' chunk with the shader bytecode.");
-        return false;
+        return {};
     }
 
     // update checksum
     DWORD Checksum[4] = {};
     CalculateDXBCChecksum(reinterpret_cast<BYTE*>(Ptr), static_cast<DWORD>(Size), Checksum);
 
     static_assert(sizeof(Header.Checksum) == sizeof(Checksum), "Unexpected checksum size");
-    memcpy(Header.Checksum, Checksum, sizeof(Header.Checksum));
+    memcpy(pRemappedBytecode->GetDataPtr<DXBCHeader>()->Checksum, Checksum, sizeof(Header.Checksum));
 
-    return true;
+    return pRemappedBytecode;
 }
 
 } // namespace DXBCUtils
diff --git a/Tests/DiligentCoreAPITest/src/DXBCUtilsTest.cpp b/Tests/DiligentCoreAPITest/src/DXBCUtilsTest.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -49,19 +49,20 @@ void TestDXBCRemapping(const char* Source, const char* Entry, const char* Profil
     CComPtr<ID3DBlob> Blob;
     CComPtr<ID3DBlob> CompilerOutput;
 
-    auto hr = D3DCompile(Source, strlen(Source), nullptr, nullptr, nullptr, Entry, Profile, D3DCOMPILE_ENABLE_STRICTNESS, 0, &Blob, &CompilerOutput);
+    HRESULT hr = D3DCompile(Source, strlen(Source), nullptr, nullptr, nullptr, Entry, Profile, D3DCOMPILE_ENABLE_STRICTNESS, 0, &Blob, &CompilerOutput);
     if (FAILED(hr))
     {
         const char* Msg = CompilerOutput ? static_cast<char*>(CompilerOutput->GetBufferPointer()) : "";
         LOG_ERROR_MESSAGE("D3DCompile failed: ", Msg);
     }
     ASSERT_HRESULT_SUCCEEDED(hr);
 
-    ASSERT_TRUE(DXBCUtils::RemapResourceBindings(ResMap, Blob->GetBufferPointer(), Blob->GetBufferSize()));
+    RefCntAutoPtr<IDataBlob> RemappedByteCode = DXBCUtils::RemapResourceBindings(ResMap, Blob->GetBufferPointer(), Blob->GetBufferSize());
+    ASSERT_TRUE(RemappedByteCode);
 
     CComPtr<ID3D12ShaderReflection> ShaderReflection;
 
-    hr = D3DReflect(Blob->GetBufferPointer(), Blob->GetBufferSize(), __uuidof(ShaderReflection), reinterpret_cast<void**>(&ShaderReflection));
+    hr = D3DReflect(RemappedByteCode->GetConstDataPtr(), RemappedByteCode->GetSize(), __uuidof(ShaderReflection), reinterpret_cast<void**>(&ShaderReflection));
     ASSERT_HRESULT_SUCCEEDED(hr);
 
     D3D12_SHADER_DESC ShaderDesc = {};

Original file line number	Diff line number	Diff line change
`@@ -141,8 +141,8 @@ void PipelineStateD3D11Impl::RemapOrVerifyShaderResources(const TShaderStages&`
`141`	`141`
`142`	`142`	`if (HandleRemappedBytecodeFn)`
`143`	`143`	`{`
`144`		`- RefCntAutoPtr<IDataBlob> pPatchedBytecode = DataBlobImpl::MakeCopy(pBytecode);`
`145`		`- if (!DXBCUtils::RemapResourceBindings(ResourceMap, pPatchedBytecode->GetDataPtr(), pPatchedBytecode->GetSize()))`
	`144`	`+ RefCntAutoPtr<IDataBlob> pPatchedBytecode = DXBCUtils::RemapResourceBindings(ResourceMap, pBytecode->GetConstDataPtr(), pBytecode->GetSize());`
	`145`	`+ if (!pPatchedBytecode)`
`146`	`146`	`LOG_ERROR_AND_THROW("Failed to remap resource bindings in shader '", pShader->GetDesc().Name, "'.");`
`147`	`147`
`148`	`148`	`HandleRemappedBytecodeFn(s, pShader, pPatchedBytecode);`
Original file line number	Diff line number	Diff line change
`@@ -491,8 +491,8 @@ void PipelineStateD3D12Impl::RemapOrVerifyShaderResources(TShaderStages&`
`491`	`491`	`}`
`492`	`492`	`else`
`493`	`493`	`{`
`494`		`- pBytecode = DataBlobImpl::MakeCopy(pBytecode);`
`495`		`- if (!DXBCUtils::RemapResourceBindings(ResourceMap, pBytecode->GetDataPtr(), pBytecode->GetSize()))`
	`494`	`+ pBytecode = DXBCUtils::RemapResourceBindings(ResourceMap, pBytecode->GetDataPtr(), pBytecode->GetSize());`
	`495`	`+ if (!pBytecode)`
`496`	`496`	`LOG_ERROR_AND_THROW("Failed to remap resource bindings in shader '", pShader->GetDesc().Name, "'.");`
`497`	`497`	`}`
`498`	`498`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@`
`36`	`36`
`37`	`37`	`#include "DXBCUtils.hpp"`
`38`	`38`	`#include "../../../ThirdParty/GPUOpenShaderUtils/DXBCChecksum.h"`
	`39`	`+#include "DataBlobImpl.hpp"`
`39`	`40`
`40`	`41`	`namespace Diligent`
`41`	`42`	`{`
`@@ -1700,37 +1701,34 @@ void ShaderBytecodeRemapper::PatchBytecode(Uint32* Token, const void* EndPtr) no`
`1700`	`1701`	`namespace DXBCUtils`
`1701`	`1702`	`{`
`1702`	`1703`
`1703`		`-bool RemapResourceBindings(const TResourceBindingMap& ResourceMap,`
`1704`		`- void* pBytecode,`
`1705`		`- size_t Size)`
	`1704`	`+RefCntAutoPtr<IDataBlob> RemapResourceBindings(const TResourceBindingMap& ResourceMap,`
	`1705`	`+ const void* pBytecode,`
	`1706`	`+ size_t Size)`
`1706`	`1707`	`{`
`1707`	`1708`	`if (pBytecode == nullptr)`
`1708`	`1709`	`{`
`1709`	`1710`	`LOG_ERROR_MESSAGE("pBytecode must not be null.");`
`1710`		`- return false;`
	`1711`	`+ return {};`
`1711`	`1712`	`}`
`1712`	`1713`
`1713`		`- char* const Ptr = static_cast<char*>(pBytecode);`
`1714`		`- const void* const EndPtr = Ptr + Size;`
`1715`		`-`
`1716`	`1714`	`if (Size < sizeof(DXBCHeader))`
`1717`	`1715`	`{`
`1718`	`1716`	`LOG_ERROR_MESSAGE("The size of the byte code (", Size, ") is too small to contain the DXBC header. The byte code may be corrupted.");`
`1719`		`- return false;`
	`1717`	`+ return {};`
`1720`	`1718`	`}`
`1721`	`1719`
`1722`		`- DXBCHeader& Header = reinterpret_cast<DXBCHeader>(Ptr);`
	`1720`	`+ const DXBCHeader& Header = static_cast<const DXBCHeader>(pBytecode);`
`1723`	`1721`	`if (Header.TotalSize != Size)`
`1724`	`1722`	`{`
`1725`	`1723`	`LOG_ERROR_MESSAGE("The byte code size (", Header.TotalSize, ") specified in the header does not match the actual size (", Size,`
`1726`	`1724`	`"). The byte code may be corrupted.");`
`1727`		`- return false;`
	`1725`	`+ return {};`
`1728`	`1726`	`}`
`1729`	`1727`
`1730`	`1728`	`#ifdef DILIGENT_DEVELOPMENT`
`1731`	`1729`	`{`
`1732`	`1730`	`DWORD Checksum[4] = {};`
`1733`		`- CalculateDXBCChecksum(reinterpret_cast<BYTE*>(Ptr), static_cast<DWORD>(Size), Checksum);`
	`1731`	`+ CalculateDXBCChecksum(static_cast<const BYTE*>(pBytecode), static_cast<DWORD>(Size), Checksum);`
`1734`	`1732`
`1735`	`1733`	`DEV_CHECK_ERR((Checksum[0] == Header.Checksum[0] &&`
`1736`	`1734`	`Checksum[1] == Header.Checksum[1] &&`
`@@ -1743,9 +1741,14 @@ bool RemapResourceBindings(const TResourceBindingMap& ResourceMap,`
`1743`	`1741`	`if (Header.Magic != DXBCFourCC)`
`1744`	`1742`	`{`
`1745`	`1743`	`LOG_ERROR_MESSAGE("Bytecode header does not contain the 'DXBC' magic number. The byte code may be corrupted.");`
`1746`		`- return false;`
	`1744`	`+ return {};`
`1747`	`1745`	`}`
`1748`	`1746`
	`1747`	`+ RefCntAutoPtr<IDataBlob> pRemappedBytecode = DataBlobImpl::Create(Size, pBytecode);`
	`1748`	`+`
	`1749`	`+ char* const Ptr = pRemappedBytecode->GetDataPtr<char>();`
	`1750`	`+ const void* const EndPtr = Ptr + Size;`
	`1751`	`+`
`1749`	`1752`	`const Uint32* Chunks = reinterpret_cast<Uint32*>(Ptr + sizeof(Header));`
`1750`	`1753`	`ResourceBindingPerType BindingsPerType;`
`1751`	`1754`	`TExtendedResourceMap ExtResourceMap;`
`@@ -1760,12 +1763,12 @@ bool RemapResourceBindings(const TResourceBindingMap& ResourceMap,`
`1760`	`1763`	`if (pChunk + 1 > EndPtr)`
`1761`	`1764`	`{`
`1762`	`1765`	`LOG_ERROR_MESSAGE("Not enough space for the chunk header. The byte code may be corrupted.");`
`1763`		`- return false;`
	`1766`	`+ return {};`
`1764`	`1767`	`}`
`1765`	`1768`	`if ((Ptr + Chunks[i] + pChunk->Length) > EndPtr)`
`1766`	`1769`	`{`
`1767`	`1770`	`LOG_ERROR_MESSAGE("Not enough space for the chunk data. The byte code may be corrupted.");`
`1768`		`- return false;`
	`1771`	`+ return {};`
`1769`	`1772`	`}`
`1770`	`1773`
`1771`	`1774`	`if (pChunk->Magic == RDEFFourCC)`
`@@ -1801,29 +1804,29 @@ bool RemapResourceBindings(const TResourceBindingMap& ResourceMap,`
`1801`	`1804`	`}`
`1802`	`1805`	`catch (...)`
`1803`	`1806`	`{`
`1804`		`- return false;`
	`1807`	`+ return {};`
`1805`	`1808`	`}`
`1806`	`1809`
`1807`	`1810`	`if (!RemapResDef)`
`1808`	`1811`	`{`
`1809`	`1812`	`LOG_ERROR_MESSAGE("Failed to find 'RDEF' chunk with the resource definition.");`
`1810`		`- return false;`
	`1813`	`+ return {};`
`1811`	`1814`	`}`
`1812`	`1815`
`1813`	`1816`	`if (!RemapBytecode)`
`1814`	`1817`	`{`
`1815`	`1818`	`LOG_ERROR_MESSAGE("Failed to find 'SHDR' or 'SHEX' chunk with the shader bytecode.");`
`1816`		`- return false;`
	`1819`	`+ return {};`
`1817`	`1820`	`}`
`1818`	`1821`
`1819`	`1822`	`// update checksum`
`1820`	`1823`	`DWORD Checksum[4] = {};`
`1821`	`1824`	`CalculateDXBCChecksum(reinterpret_cast<BYTE*>(Ptr), static_cast<DWORD>(Size), Checksum);`
`1822`	`1825`
`1823`	`1826`	`static_assert(sizeof(Header.Checksum) == sizeof(Checksum), "Unexpected checksum size");`
`1824`		`- memcpy(Header.Checksum, Checksum, sizeof(Header.Checksum));`
	`1827`	`+ memcpy(pRemappedBytecode->GetDataPtr<DXBCHeader>()->Checksum, Checksum, sizeof(Header.Checksum));`
`1825`	`1828`
`1826`		`- return true;`
	`1829`	`+ return pRemappedBytecode;`
`1827`	`1830`	`}`
`1828`	`1831`
`1829`	`1832`	`} // namespace DXBCUtils`