DXBCUtils::RemapResourceBindings: work with std::vector<Uint8> internally

TheMostDiligent · TheMostDiligent · commit 58d45cb8f5b1 · 2025-03-02T19:41:08.000-08:00
diff --git a/Common/interface/DataBlobImpl.hpp b/Common/interface/DataBlobImpl.hpp
@@ -45,11 +45,12 @@ namespace Diligent
 class DataBlobImpl final : public Diligent::ObjectBase<IDataBlob>
 {
 public:
-    typedef ObjectBase<IDataBlob> TBase;
+    using TBase          = ObjectBase<IDataBlob>;
+    using DataBufferType = std::vector<Uint8, STDAllocatorRawMem<Uint8>>;
 
     static RefCntAutoPtr<DataBlobImpl> Create(size_t InitialSize = 0, const void* pData = nullptr);
     static RefCntAutoPtr<DataBlobImpl> Create(IMemoryAllocator* pAllocator, size_t InitialSize = 0, const void* pData = nullptr);
-    static RefCntAutoPtr<DataBlobImpl> Create(std::vector<Uint8, STDAllocatorRawMem<Uint8>>&& DataBuff) noexcept;
+    static RefCntAutoPtr<DataBlobImpl> Create(DataBufferType&& DataBuff) noexcept;
     static RefCntAutoPtr<DataBlobImpl> MakeCopy(const IDataBlob* pDataBlob);
 
     ~DataBlobImpl() override;
@@ -89,11 +90,11 @@ class DataBlobImpl final : public Diligent::ObjectBase<IDataBlob>
                  size_t              InitialSize = 0,
                  const void*         pData       = nullptr);
 
-    DataBlobImpl(IReferenceCounters*                             pRefCounters,
-                 std::vector<Uint8, STDAllocatorRawMem<Uint8>>&& DataBuff) noexcept;
+    DataBlobImpl(IReferenceCounters* pRefCounters,
+                 DataBufferType&&    DataBuff) noexcept;
 
 private:
-    std::vector<Uint8, STDAllocatorRawMem<Uint8>> m_DataBuff;
+    DataBufferType m_DataBuff;
 };
 
 class DataBlobAllocatorAdapter final : public IMemoryAllocator
diff --git a/Common/src/DataBlobImpl.cpp b/Common/src/DataBlobImpl.cpp
@@ -46,7 +46,7 @@ RefCntAutoPtr<DataBlobImpl> DataBlobImpl::Create(size_t InitialSize, const void*
     return Create(nullptr, InitialSize, pData);
 }
 
-RefCntAutoPtr<DataBlobImpl> DataBlobImpl::Create(std::vector<Uint8, STDAllocatorRawMem<Uint8>>&& DataBuff) noexcept
+RefCntAutoPtr<DataBlobImpl> DataBlobImpl::Create(DataBufferType&& DataBuff) noexcept
 {
     return RefCntAutoPtr<DataBlobImpl>{MakeNewRCObj<DataBlobImpl>()(std::move(DataBuff))};
 }
@@ -72,8 +72,8 @@ DataBlobImpl::DataBlobImpl(IReferenceCounters* pRefCounters,
     }
 }
 
-DataBlobImpl::DataBlobImpl(IReferenceCounters*                             pRefCounters,
-                           std::vector<Uint8, STDAllocatorRawMem<Uint8>>&& DataBuff) noexcept :
+DataBlobImpl::DataBlobImpl(IReferenceCounters* pRefCounters,
+                           DataBufferType&&    DataBuff) noexcept :
     TBase{pRefCounters},
     m_DataBuff{std::move(DataBuff)}
 {
diff --git a/Graphics/ShaderTools/src/DXBCUtils.cpp b/Graphics/ShaderTools/src/DXBCUtils.cpp
@@ -37,6 +37,7 @@
 #include "DXBCUtils.hpp"
 #include "../../../ThirdParty/GPUOpenShaderUtils/DXBCChecksum.h"
 #include "DataBlobImpl.hpp"
+#include "DefaultRawMemoryAllocator.hpp"
 
 namespace Diligent
 {
@@ -871,19 +872,19 @@ inline bool PatchSpace(ResourceBindingInfo50&, ResourceExtendedInfo& Ext, const
 }
 
 template <typename ResourceBindingInfoType>
-void RemapShaderResources(const DXBCUtils::TResourceBindingMap& ResourceMap, const void* EndPtr, ResourceDefChunkHeader* RDEFHeader, TExtendedResourceMap& ExtResMap, ResourceBindingPerType& BindingsPerType)
+void RemapShaderResources(const DXBCUtils::TResourceBindingMap& ResourceMap, const void* EndPtr, ResourceDefChunkHeader& RDEFHeader, TExtendedResourceMap& ExtResMap, ResourceBindingPerType& BindingsPerType)
 {
-    VERIFY_EXPR(RDEFHeader->Magic == RDEFFourCC);
+    VERIFY_EXPR(RDEFHeader.Magic == RDEFFourCC);
 
-    char*                    Ptr        = reinterpret_cast<char*>(RDEFHeader) + sizeof(ChunkHeader);
-    ResourceBindingInfoType* ResBinding = reinterpret_cast<ResourceBindingInfoType*>(Ptr + RDEFHeader->ResBindingOffset);
-    if (ResBinding + RDEFHeader->ResBindingCount > EndPtr)
+    char*                    Ptr        = reinterpret_cast<char*>(&RDEFHeader) + sizeof(ChunkHeader);
+    ResourceBindingInfoType* ResBinding = reinterpret_cast<ResourceBindingInfoType*>(Ptr + RDEFHeader.ResBindingOffset);
+    if (ResBinding + RDEFHeader.ResBindingCount > EndPtr)
     {
         LOG_ERROR_AND_THROW("Resource binding data is outside of the specified byte code range. The byte code may be corrupted.");
     }
 
     String TempName;
-    for (Uint32 r = 0; r < RDEFHeader->ResBindingCount; ++r)
+    for (Uint32 r = 0; r < RDEFHeader.ResBindingCount; ++r)
     {
         ResourceBindingInfoType& Res  = ResBinding[r];
         const char*              Name = Ptr + Res.NameOffset;
@@ -1744,61 +1745,70 @@ RefCntAutoPtr<IDataBlob> RemapResourceBindings(const TResourceBindingMap& Resour
         return {};
     }
 
-    RefCntAutoPtr<IDataBlob> pRemappedBytecode = DataBlobImpl::Create(Size, pBytecode);
+    if (sizeof(Header) + sizeof(Uint32) * Header.ChunkCount > Size)
+    {
+        LOG_ERROR_MESSAGE("Not enough space for the chunk offsets. The byte code may be corrupted.");
+        return {};
+    }
 
-    char* const       Ptr    = pRemappedBytecode->GetDataPtr<char>();
-    const void* const EndPtr = Ptr + Size;
+    DataBlobImpl::DataBufferType RemappedBytecode{
+        static_cast<const Uint8*>(pBytecode),
+        static_cast<const Uint8*>(pBytecode) + Size,
+        STD_ALLOCATOR_RAW_MEM(Uint8, DefaultRawMemoryAllocator::GetAllocator(), "Allocator for vector<Uint8>"),
+    };
 
-    const Uint32*          Chunks = reinterpret_cast<Uint32*>(Ptr + sizeof(Header));
     ResourceBindingPerType BindingsPerType;
     TExtendedResourceMap   ExtResourceMap;
 
-    bool RemapResDef   = false;
-    bool RemapBytecode = false;
+    bool RemapResDef = false;
+    bool PatchOK     = false;
     try
     {
         for (Uint32 i = 0; i < Header.ChunkCount; ++i)
         {
-            ChunkHeader* pChunk = reinterpret_cast<ChunkHeader*>(Ptr + Chunks[i]);
-            if (pChunk + 1 > EndPtr)
+            const Uint32* ChunkOffsets = reinterpret_cast<const Uint32*>(&RemappedBytecode[sizeof(Header)]);
+            const Uint32  ChunkOffset  = ChunkOffsets[i];
+            if (ChunkOffset + sizeof(ChunkHeader) > RemappedBytecode.size())
             {
                 LOG_ERROR_MESSAGE("Not enough space for the chunk header. The byte code may be corrupted.");
                 return {};
             }
-            if ((Ptr + Chunks[i] + pChunk->Length) > EndPtr)
+
+            ChunkHeader& Chunk = reinterpret_cast<ChunkHeader&>(RemappedBytecode[ChunkOffset]);
+            if (ChunkOffset + Chunk.Length > RemappedBytecode.size())
             {
                 LOG_ERROR_MESSAGE("Not enough space for the chunk data. The byte code may be corrupted.");
                 return {};
             }
 
-            if (pChunk->Magic == RDEFFourCC)
+            if (Chunk.Magic == RDEFFourCC)
             {
-                ResourceDefChunkHeader* RDEFHeader = reinterpret_cast<ResourceDefChunkHeader*>(pChunk);
+                ResourceDefChunkHeader& RDEFHeader = reinterpret_cast<ResourceDefChunkHeader&>(Chunk);
 
-                if (RDEFHeader->MajorVersion == 5 && RDEFHeader->MinorVersion == 1)
+                if (RDEFHeader.MajorVersion == 5 && RDEFHeader.MinorVersion == 1)
                 {
-                    RemapShaderResources<ResourceBindingInfo51>(ResourceMap, EndPtr, RDEFHeader, ExtResourceMap, BindingsPerType);
+                    RemapShaderResources<ResourceBindingInfo51>(ResourceMap, RemappedBytecode.data() + RemappedBytecode.size(), RDEFHeader, ExtResourceMap, BindingsPerType);
                     RemapResDef = true;
                 }
-                else if ((RDEFHeader->MajorVersion == 5 && RDEFHeader->MinorVersion == 0) || RDEFHeader->MajorVersion < 5)
+                else if ((RDEFHeader.MajorVersion == 5 && RDEFHeader.MinorVersion == 0) || RDEFHeader.MajorVersion < 5)
                 {
-                    RemapShaderResources<ResourceBindingInfo50>(ResourceMap, EndPtr, RDEFHeader, ExtResourceMap, BindingsPerType);
+                    RemapShaderResources<ResourceBindingInfo50>(ResourceMap, RemappedBytecode.data() + RemappedBytecode.size(), RDEFHeader, ExtResourceMap, BindingsPerType);
                     RemapResDef = true;
                 }
                 else
                 {
-                    LOG_ERROR_MESSAGE("Unexpected shader model: ", RDEFHeader->MajorVersion, '.', RDEFHeader->MinorVersion);
+                    LOG_ERROR_MESSAGE("Unexpected shader model: ", RDEFHeader.MajorVersion, '.', RDEFHeader.MinorVersion);
                 }
             }
 
-            if (pChunk->Magic == SHDRFourCC || pChunk->Magic == SHEXFourCC)
+            if (Chunk.Magic == SHDRFourCC || Chunk.Magic == SHEXFourCC)
             {
-                Uint32*                  Token    = reinterpret_cast<Uint32*>(Ptr + Chunks[i] + sizeof(ShaderChunkHeader));
-                const ShaderChunkHeader& SBHeader = *reinterpret_cast<ShaderChunkHeader*>(pChunk);
+                Uint32*                  Token    = reinterpret_cast<Uint32*>(&RemappedBytecode[ChunkOffset + sizeof(ShaderChunkHeader)]);
+                const ShaderChunkHeader& SBHeader = reinterpret_cast<ShaderChunkHeader&>(Chunk);
                 ShaderBytecodeRemapper   Remapper{SBHeader, ExtResourceMap, BindingsPerType};
 
-                Remapper.PatchBytecode(Token, EndPtr);
-                RemapBytecode = true;
+                Remapper.PatchBytecode(Token, RemappedBytecode.data() + RemappedBytecode.size());
+                PatchOK = true;
             }
         }
     }
@@ -1813,20 +1823,20 @@ RefCntAutoPtr<IDataBlob> RemapResourceBindings(const TResourceBindingMap& Resour
         return {};
     }
 
-    if (!RemapBytecode)
+    if (!PatchOK)
     {
         LOG_ERROR_MESSAGE("Failed to find 'SHDR' or 'SHEX' chunk with the shader bytecode.");
         return {};
     }
 
     // update checksum
     DWORD Checksum[4] = {};
-    CalculateDXBCChecksum(reinterpret_cast<BYTE*>(Ptr), static_cast<DWORD>(Size), Checksum);
+    CalculateDXBCChecksum(reinterpret_cast<BYTE*>(RemappedBytecode.data()), static_cast<DWORD>(RemappedBytecode.size()), Checksum);
 
     static_assert(sizeof(Header.Checksum) == sizeof(Checksum), "Unexpected checksum size");
-    memcpy(pRemappedBytecode->GetDataPtr<DXBCHeader>()->Checksum, Checksum, sizeof(Header.Checksum));
+    memcpy(reinterpret_cast<DXBCHeader*>(RemappedBytecode.data())->Checksum, Checksum, sizeof(Header.Checksum));
 
-    return pRemappedBytecode;
+    return DataBlobImpl::Create(std::move(RemappedBytecode));
 }
 
 } // namespace DXBCUtils

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ RefCntAutoPtr<DataBlobImpl> DataBlobImpl::Create(size_t InitialSize, const void*`
`46`	`46`	`return Create(nullptr, InitialSize, pData);`
`47`	`47`	`}`
`48`	`48`
`49`		`-RefCntAutoPtr<DataBlobImpl> DataBlobImpl::Create(std::vector<Uint8, STDAllocatorRawMem<Uint8>>&& DataBuff) noexcept`
	`49`	`+RefCntAutoPtr<DataBlobImpl> DataBlobImpl::Create(DataBufferType&& DataBuff) noexcept`
`50`	`50`	`{`
`51`	`51`	`return RefCntAutoPtr<DataBlobImpl>{MakeNewRCObj<DataBlobImpl>()(std::move(DataBuff))};`
`52`	`52`	`}`
`@@ -72,8 +72,8 @@ DataBlobImpl::DataBlobImpl(IReferenceCounters* pRefCounters,`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`		`-DataBlobImpl::DataBlobImpl(IReferenceCounters* pRefCounters,`
`76`		`- std::vector<Uint8, STDAllocatorRawMem<Uint8>>&& DataBuff) noexcept :`
	`75`	`+DataBlobImpl::DataBlobImpl(IReferenceCounters* pRefCounters,`
	`76`	`+ DataBufferType&& DataBuff) noexcept :`
`77`	`77`	`TBase{pRefCounters},`
`78`	`78`	`m_DataBuff{std::move(DataBuff)}`
`79`	`79`	`{`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,7 @@`
`37`	`37`	`#include "DXBCUtils.hpp"`
`38`	`38`	`#include "../../../ThirdParty/GPUOpenShaderUtils/DXBCChecksum.h"`
`39`	`39`	`#include "DataBlobImpl.hpp"`
	`40`	`+#include "DefaultRawMemoryAllocator.hpp"`
`40`	`41`
`41`	`42`	`namespace Diligent`
`42`	`43`	`{`
`@@ -871,19 +872,19 @@ inline bool PatchSpace(ResourceBindingInfo50&, ResourceExtendedInfo& Ext, const`
`871`	`872`	`}`
`872`	`873`
`873`	`874`	`template <typename ResourceBindingInfoType>`
`874`		`-void RemapShaderResources(const DXBCUtils::TResourceBindingMap& ResourceMap, const void* EndPtr, ResourceDefChunkHeader* RDEFHeader, TExtendedResourceMap& ExtResMap, ResourceBindingPerType& BindingsPerType)`
	`875`	`+void RemapShaderResources(const DXBCUtils::TResourceBindingMap& ResourceMap, const void* EndPtr, ResourceDefChunkHeader& RDEFHeader, TExtendedResourceMap& ExtResMap, ResourceBindingPerType& BindingsPerType)`
`875`	`876`	`{`
`876`		`- VERIFY_EXPR(RDEFHeader->Magic == RDEFFourCC);`
	`877`	`+ VERIFY_EXPR(RDEFHeader.Magic == RDEFFourCC);`
`877`	`878`
`878`		`- char* Ptr = reinterpret_cast<char*>(RDEFHeader) + sizeof(ChunkHeader);`
`879`		`- ResourceBindingInfoType* ResBinding = reinterpret_cast<ResourceBindingInfoType*>(Ptr + RDEFHeader->ResBindingOffset);`
`880`		`- if (ResBinding + RDEFHeader->ResBindingCount > EndPtr)`
	`879`	`+ char* Ptr = reinterpret_cast<char*>(&RDEFHeader) + sizeof(ChunkHeader);`
	`880`	`+ ResourceBindingInfoType* ResBinding = reinterpret_cast<ResourceBindingInfoType*>(Ptr + RDEFHeader.ResBindingOffset);`
	`881`	`+ if (ResBinding + RDEFHeader.ResBindingCount > EndPtr)`
`881`	`882`	`{`
`882`	`883`	`LOG_ERROR_AND_THROW("Resource binding data is outside of the specified byte code range. The byte code may be corrupted.");`
`883`	`884`	`}`
`884`	`885`
`885`	`886`	`String TempName;`
`886`		`- for (Uint32 r = 0; r < RDEFHeader->ResBindingCount; ++r)`
	`887`	`+ for (Uint32 r = 0; r < RDEFHeader.ResBindingCount; ++r)`
`887`	`888`	`{`
`888`	`889`	`ResourceBindingInfoType& Res = ResBinding[r];`
`889`	`890`	`const char* Name = Ptr + Res.NameOffset;`
`@@ -1744,61 +1745,70 @@ RefCntAutoPtr<IDataBlob> RemapResourceBindings(const TResourceBindingMap& Resour`
`1744`	`1745`	`return {};`
`1745`	`1746`	`}`
`1746`	`1747`
`1747`		`- RefCntAutoPtr<IDataBlob> pRemappedBytecode = DataBlobImpl::Create(Size, pBytecode);`
	`1748`	`+ if (sizeof(Header) + sizeof(Uint32) * Header.ChunkCount > Size)`
	`1749`	`+ {`
	`1750`	`+ LOG_ERROR_MESSAGE("Not enough space for the chunk offsets. The byte code may be corrupted.");`
	`1751`	`+ return {};`
	`1752`	`+ }`
`1748`	`1753`
`1749`		`- char* const Ptr = pRemappedBytecode->GetDataPtr<char>();`
`1750`		`- const void* const EndPtr = Ptr + Size;`
	`1754`	`+ DataBlobImpl::DataBufferType RemappedBytecode{`
	`1755`	`+ static_cast<const Uint8*>(pBytecode),`
	`1756`	`+ static_cast<const Uint8*>(pBytecode) + Size,`
	`1757`	`+ STD_ALLOCATOR_RAW_MEM(Uint8, DefaultRawMemoryAllocator::GetAllocator(), "Allocator for vector<Uint8>"),`
	`1758`	`+ };`
`1751`	`1759`
`1752`		`- const Uint32* Chunks = reinterpret_cast<Uint32*>(Ptr + sizeof(Header));`
`1753`	`1760`	`ResourceBindingPerType BindingsPerType;`
`1754`	`1761`	`TExtendedResourceMap ExtResourceMap;`
`1755`	`1762`
`1756`		`- bool RemapResDef = false;`
`1757`		`- bool RemapBytecode = false;`
	`1763`	`+ bool RemapResDef = false;`
	`1764`	`+ bool PatchOK = false;`
`1758`	`1765`	`try`
`1759`	`1766`	`{`
`1760`	`1767`	`for (Uint32 i = 0; i < Header.ChunkCount; ++i)`
`1761`	`1768`	`{`
`1762`		`- ChunkHeader* pChunk = reinterpret_cast<ChunkHeader*>(Ptr + Chunks[i]);`
`1763`		`- if (pChunk + 1 > EndPtr)`
	`1769`	`+ const Uint32* ChunkOffsets = reinterpret_cast<const Uint32*>(&RemappedBytecode[sizeof(Header)]);`
	`1770`	`+ const Uint32 ChunkOffset = ChunkOffsets[i];`
	`1771`	`+ if (ChunkOffset + sizeof(ChunkHeader) > RemappedBytecode.size())`
`1764`	`1772`	`{`
`1765`	`1773`	`LOG_ERROR_MESSAGE("Not enough space for the chunk header. The byte code may be corrupted.");`
`1766`	`1774`	`return {};`
`1767`	`1775`	`}`
`1768`		`- if ((Ptr + Chunks[i] + pChunk->Length) > EndPtr)`
	`1776`	`+`
	`1777`	`+ ChunkHeader& Chunk = reinterpret_cast<ChunkHeader&>(RemappedBytecode[ChunkOffset]);`
	`1778`	`+ if (ChunkOffset + Chunk.Length > RemappedBytecode.size())`
`1769`	`1779`	`{`
`1770`	`1780`	`LOG_ERROR_MESSAGE("Not enough space for the chunk data. The byte code may be corrupted.");`
`1771`	`1781`	`return {};`
`1772`	`1782`	`}`
`1773`	`1783`
`1774`		`- if (pChunk->Magic == RDEFFourCC)`
	`1784`	`+ if (Chunk.Magic == RDEFFourCC)`
`1775`	`1785`	`{`
`1776`		`- ResourceDefChunkHeader* RDEFHeader = reinterpret_cast<ResourceDefChunkHeader*>(pChunk);`
	`1786`	`+ ResourceDefChunkHeader& RDEFHeader = reinterpret_cast<ResourceDefChunkHeader&>(Chunk);`
`1777`	`1787`
`1778`		`- if (RDEFHeader->MajorVersion == 5 && RDEFHeader->MinorVersion == 1)`
	`1788`	`+ if (RDEFHeader.MajorVersion == 5 && RDEFHeader.MinorVersion == 1)`
`1779`	`1789`	`{`
`1780`		`- RemapShaderResources<ResourceBindingInfo51>(ResourceMap, EndPtr, RDEFHeader, ExtResourceMap, BindingsPerType);`
	`1790`	`+ RemapShaderResources<ResourceBindingInfo51>(ResourceMap, RemappedBytecode.data() + RemappedBytecode.size(), RDEFHeader, ExtResourceMap, BindingsPerType);`
`1781`	`1791`	`RemapResDef = true;`
`1782`	`1792`	`}`
`1783`		`- else if ((RDEFHeader->MajorVersion == 5 && RDEFHeader->MinorVersion == 0) \|\| RDEFHeader->MajorVersion < 5)`
	`1793`	`+ else if ((RDEFHeader.MajorVersion == 5 && RDEFHeader.MinorVersion == 0) \|\| RDEFHeader.MajorVersion < 5)`
`1784`	`1794`	`{`
`1785`		`- RemapShaderResources<ResourceBindingInfo50>(ResourceMap, EndPtr, RDEFHeader, ExtResourceMap, BindingsPerType);`
	`1795`	`+ RemapShaderResources<ResourceBindingInfo50>(ResourceMap, RemappedBytecode.data() + RemappedBytecode.size(), RDEFHeader, ExtResourceMap, BindingsPerType);`
`1786`	`1796`	`RemapResDef = true;`
`1787`	`1797`	`}`
`1788`	`1798`	`else`
`1789`	`1799`	`{`
`1790`		`- LOG_ERROR_MESSAGE("Unexpected shader model: ", RDEFHeader->MajorVersion, '.', RDEFHeader->MinorVersion);`
	`1800`	`+ LOG_ERROR_MESSAGE("Unexpected shader model: ", RDEFHeader.MajorVersion, '.', RDEFHeader.MinorVersion);`
`1791`	`1801`	`}`
`1792`	`1802`	`}`
`1793`	`1803`
`1794`		`- if (pChunk->Magic == SHDRFourCC \|\| pChunk->Magic == SHEXFourCC)`
	`1804`	`+ if (Chunk.Magic == SHDRFourCC \|\| Chunk.Magic == SHEXFourCC)`
`1795`	`1805`	`{`
`1796`		`- Uint32* Token = reinterpret_cast<Uint32*>(Ptr + Chunks[i] + sizeof(ShaderChunkHeader));`
`1797`		`- const ShaderChunkHeader& SBHeader = reinterpret_cast<ShaderChunkHeader>(pChunk);`
	`1806`	`+ Uint32* Token = reinterpret_cast<Uint32*>(&RemappedBytecode[ChunkOffset + sizeof(ShaderChunkHeader)]);`
	`1807`	`+ const ShaderChunkHeader& SBHeader = reinterpret_cast<ShaderChunkHeader&>(Chunk);`
`1798`	`1808`	`ShaderBytecodeRemapper Remapper{SBHeader, ExtResourceMap, BindingsPerType};`
`1799`	`1809`
`1800`		`- Remapper.PatchBytecode(Token, EndPtr);`
`1801`		`- RemapBytecode = true;`
	`1810`	`+ Remapper.PatchBytecode(Token, RemappedBytecode.data() + RemappedBytecode.size());`
	`1811`	`+ PatchOK = true;`
`1802`	`1812`	`}`
`1803`	`1813`	`}`
`1804`	`1814`	`}`
`@@ -1813,20 +1823,20 @@ RefCntAutoPtr<IDataBlob> RemapResourceBindings(const TResourceBindingMap& Resour`
`1813`	`1823`	`return {};`
`1814`	`1824`	`}`
`1815`	`1825`
`1816`		`- if (!RemapBytecode)`
	`1826`	`+ if (!PatchOK)`
`1817`	`1827`	`{`
`1818`	`1828`	`LOG_ERROR_MESSAGE("Failed to find 'SHDR' or 'SHEX' chunk with the shader bytecode.");`
`1819`	`1829`	`return {};`
`1820`	`1830`	`}`
`1821`	`1831`
`1822`	`1832`	`// update checksum`
`1823`	`1833`	`DWORD Checksum[4] = {};`
`1824`		`- CalculateDXBCChecksum(reinterpret_cast<BYTE*>(Ptr), static_cast<DWORD>(Size), Checksum);`
	`1834`	`+ CalculateDXBCChecksum(reinterpret_cast<BYTE*>(RemappedBytecode.data()), static_cast<DWORD>(RemappedBytecode.size()), Checksum);`
`1825`	`1835`
`1826`	`1836`	`static_assert(sizeof(Header.Checksum) == sizeof(Checksum), "Unexpected checksum size");`
`1827`		`- memcpy(pRemappedBytecode->GetDataPtr<DXBCHeader>()->Checksum, Checksum, sizeof(Header.Checksum));`
	`1837`	`+ memcpy(reinterpret_cast<DXBCHeader*>(RemappedBytecode.data())->Checksum, Checksum, sizeof(Header.Checksum));`
`1828`	`1838`
`1829`		`- return pRemappedBytecode;`
	`1839`	`+ return DataBlobImpl::Create(std::move(RemappedBytecode));`
`1830`	`1840`	`}`
`1831`	`1841`
`1832`	`1842`	`} // namespace DXBCUtils`