DXBCUtils: dynamically compute chunk end in ShaderBytecodeRemapper

TheMostDiligent · TheMostDiligent · commit 5f1fd99d7bbe · 2025-03-02T23:03:50.000-08:00
diff --git a/Graphics/ShaderTools/src/DXBCUtils.cpp b/Graphics/ShaderTools/src/DXBCUtils.cpp
@@ -986,7 +986,7 @@ struct ShaderBytecodeRemapper
 
         IsSM51 = Header.VersionMajor == 5 && Header.VersionMinor >= 1;
 
-        EndOffset = (ChunkOffset + sizeof(ChunkHeader) + Header.Length) / 4;
+        EndOffset = ChunkOffset + sizeof(ChunkHeader) + Header.Length;
     }
 
     void PatchBytecode(const void* ChunkEnd) noexcept(false);
@@ -1004,29 +1004,34 @@ struct ShaderBytecodeRemapper
     static constexpr Uint32 RuntimeSizedArraySize = ~0u;
 
 private:
-    void RemapResourceOperand(const OperandToken& Operand, Uint32* Token, const void* Finish);
-    void RemapResourceOperandSM50(const OperandToken& Operand, Uint32* Token, const void* Finish);
-    void RemapResourceOperandSM51(const OperandToken& Operand, Uint32* Token, const void* Finish);
+    const Uint32* GetChunkEnd() const
+    {
+        return reinterpret_cast<const Uint32*>(Bytecode.data() + EndOffset);
+    }
+
+    void RemapResourceOperand(const OperandToken& Operand, Uint32* Token);
+    void RemapResourceOperandSM50(const OperandToken& Operand, Uint32* Token);
+    void RemapResourceOperandSM51(const OperandToken& Operand, Uint32* Token);
     void RemapResourceOperandSM51_2(const OperandToken& Operand, Uint32* Token, RES_TYPE Type);
 
     void RemapResourceBinding(const OpcodeToken& Opcode, Uint32* Token, const void* Finish);
     void RemapResourceBindingSM51(const OpcodeToken& Opcode, Uint32* Token, const void* Finish);
 
-    void ParseOperand(Uint32*& Token, const void* Finish);
-    void ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION IndexType, Uint32*& Token, const void* Finish);
-    void ParseCustomData(Uint32*& Token, const void* Finish, D3D10_SB_CUSTOMDATA_CLASS Type);
-    void ParseOpcode(Uint32*& Token, const void* Finish);
+    void ParseOperand(Uint32*& Token);
+    void ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION IndexType, Uint32*& Token);
+    void ParseCustomData(Uint32*& Token, D3D10_SB_CUSTOMDATA_CLASS Type);
+    void ParseOpcode(Uint32*& Token);
 };
 
-void ShaderBytecodeRemapper::RemapResourceOperand(const OperandToken& Operand, Uint32* Token, const void* Finish)
+void ShaderBytecodeRemapper::RemapResourceOperand(const OperandToken& Operand, Uint32* Token)
 {
     if (IsSM51)
     {
-        RemapResourceOperandSM51(Operand, Token, Finish);
+        RemapResourceOperandSM51(Operand, Token);
     }
     else
     {
-        RemapResourceOperandSM50(Operand, Token, Finish);
+        RemapResourceOperandSM50(Operand, Token);
     }
 }
 
@@ -1038,7 +1043,7 @@ void ShaderBytecodeRemapper::RemapResourceBinding(const OpcodeToken& Opcode, Uin
     }
 }
 
-void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operand, Uint32* Token, const void* Finish)
+void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operand, Uint32* Token)
 {
     const auto FindResourceBindings = [this](RES_TYPE Type, Uint32& Token) //
     {
@@ -1063,7 +1068,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operan
             // 0 - cbuffer bind point
             // 1 - row offset (16 bytes per row) | cbuffer size
 
-            VERIFY_EXPR(Token + 2 <= Finish);
+            VERIFY_EXPR(Token + 2 <= GetChunkEnd());
             VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_2D);
             VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
             VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
@@ -1077,7 +1082,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operan
         {
             // 0 - sampler bind point
 
-            VERIFY_EXPR(Token + 1 <= Finish);
+            VERIFY_EXPR(Token + 1 <= GetChunkEnd());
             VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_1D);
             VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
 
@@ -1090,7 +1095,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operan
         {
             // 0 - texture bind point
 
-            VERIFY_EXPR(Token + 1 <= Finish);
+            VERIFY_EXPR(Token + 1 <= GetChunkEnd());
             VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_1D);
             VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
 
@@ -1103,7 +1108,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operan
         {
             // 0 - UAV bind point
 
-            VERIFY_EXPR(Token + 1 <= Finish);
+            VERIFY_EXPR(Token + 1 <= GetChunkEnd());
             VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_1D);
             VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
 
@@ -1157,7 +1162,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51_2(const OperandToken& Oper
     }
 }
 
-void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operand, Uint32* Token, const void* Finish)
+void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operand, Uint32* Token)
 {
     switch (Operand.OperandType)
     {
@@ -1167,7 +1172,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operan
             // 1 - cbuffer bind point
             // 2 - row offset (16 bytes per row)
 
-            VERIFY_EXPR(Token + 3 <= Finish);
+            VERIFY_EXPR(Token + 3 <= GetChunkEnd());
             VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_3D);
             VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
 
@@ -1180,7 +1185,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operan
             // 0 - sampler index in resource definition
             // 1 - sampler bind point
 
-            VERIFY_EXPR(Token + 2 <= Finish);
+            VERIFY_EXPR(Token + 2 <= GetChunkEnd());
             VERIFY_EXPR(Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_2D);
             VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
 
@@ -1193,7 +1198,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operan
             // 0 - texture index in resource definition
             // 1 - texture bind point
 
-            VERIFY_EXPR(Token + 2 <= Finish);
+            VERIFY_EXPR(Token + 2 <= GetChunkEnd());
             VERIFY_EXPR(Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_2D);
             VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
 
@@ -1206,7 +1211,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operan
             // 0 - UAV index in resource definition
             // 1 - UAV bind point
 
-            VERIFY_EXPR(Token + 2 <= Finish);
+            VERIFY_EXPR(Token + 2 <= GetChunkEnd());
             VERIFY_EXPR(Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_2D);
             VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);
 
@@ -1460,7 +1465,7 @@ void ShaderBytecodeRemapper::RemapResourceBindingSM51(const OpcodeToken& Opcode,
     }
 }
 
-void ShaderBytecodeRemapper::ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION IndexType, Uint32*& Token, const void* Finish)
+void ShaderBytecodeRemapper::ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION IndexType, Uint32*& Token)
 {
     switch (IndexType)
     {
@@ -1476,27 +1481,27 @@ void ShaderBytecodeRemapper::ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION In
         }
         case D3D10_SB_OPERAND_INDEX_RELATIVE:
         {
-            ParseOperand(Token, Finish);
+            ParseOperand(Token);
             break;
         }
         case D3D10_SB_OPERAND_INDEX_IMMEDIATE32_PLUS_RELATIVE:
         {
             Token += 1;
-            ParseOperand(Token, Finish);
+            ParseOperand(Token);
             break;
         }
         case D3D10_SB_OPERAND_INDEX_IMMEDIATE64_PLUS_RELATIVE:
         {
             Token += 2;
-            ParseOperand(Token, Finish);
+            ParseOperand(Token);
             break;
         }
         default:
             LOG_ERROR_AND_THROW("Unknown index type");
     }
 }
 
-void ShaderBytecodeRemapper::ParseOperand(Uint32*& Token, const void* Finish)
+void ShaderBytecodeRemapper::ParseOperand(Uint32*& Token)
 {
     const OperandToken& Operand = *reinterpret_cast<OperandToken*>(Token++);
 
@@ -1567,7 +1572,7 @@ void ShaderBytecodeRemapper::ParseOperand(Uint32*& Token, const void* Finish)
         case D3D10_SB_OPERAND_TYPE_CONSTANT_BUFFER:
         case D3D10_SB_OPERAND_TYPE_IMMEDIATE_CONSTANT_BUFFER:
         case D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW:
-            RemapResourceOperand(Operand, Token, Finish);
+            RemapResourceOperand(Operand, Token);
             break;
 
         default:
@@ -1577,19 +1582,19 @@ void ShaderBytecodeRemapper::ParseOperand(Uint32*& Token, const void* Finish)
     if (Operand.IndexDim != D3D10_SB_OPERAND_INDEX_0D)
     {
         if (Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_1D)
-            ParseIndex(Operand.OperandIndex1D, Token, Finish);
+            ParseIndex(Operand.OperandIndex1D, Token);
 
         if (Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_2D)
-            ParseIndex(Operand.OperandIndex2D, Token, Finish);
+            ParseIndex(Operand.OperandIndex2D, Token);
 
         if (Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_3D)
-            ParseIndex(Operand.OperandIndex3D, Token, Finish);
+            ParseIndex(Operand.OperandIndex3D, Token);
     }
 
-    VERIFY_EXPR(Token <= Finish);
+    VERIFY_EXPR(Token <= GetChunkEnd());
 }
 
-void ShaderBytecodeRemapper::ParseCustomData(Uint32*& Token, const void* Finish, D3D10_SB_CUSTOMDATA_CLASS Type)
+void ShaderBytecodeRemapper::ParseCustomData(Uint32*& Token, D3D10_SB_CUSTOMDATA_CLASS Type)
 {
     switch (Type)
     {
@@ -1605,14 +1610,14 @@ void ShaderBytecodeRemapper::ParseCustomData(Uint32*& Token, const void* Finish,
     }
 }
 
-void ShaderBytecodeRemapper::ParseOpcode(Uint32*& Token, const void* Finish)
+void ShaderBytecodeRemapper::ParseOpcode(Uint32*& Token)
 {
     // based on code from
     // https://github.com/microsoft/D3D12TranslationLayer/blob/master/src/ShaderBinary.cpp
     // Copyright (c) Microsoft Corporation.
     // MIT License
 
-    Uint32*           StartToken        = Token;
+    const ptrdiff_t   StartTokenOffset  = reinterpret_cast<const Uint8*>(Token) - Bytecode.data();
     const OpcodeToken Opcode            = reinterpret_cast<OpcodeToken&>(*Token++);
     const Uint32      NumOperands       = GetNumOperands(Opcode.OpcodeType);
     Uint32            InstructionLength = Opcode.OpcodeLength;
@@ -1646,7 +1651,7 @@ void ShaderBytecodeRemapper::ParseOpcode(Uint32*& Token, const void* Finish)
             InstructionLength                    = *Token;
             VERIFY_EXPR(InstructionLength >= 2);
 
-            ParseCustomData(Token, Finish, Type);
+            ParseCustomData(Token, Type);
             break;
         }
 
@@ -1678,18 +1683,18 @@ void ShaderBytecodeRemapper::ParseOpcode(Uint32*& Token, const void* Finish)
 
         default:
             for (Uint32 i = 0; i < NumOperands; ++i)
-                ParseOperand(Token, Finish);
+                ParseOperand(Token);
             break;
     }
 
-    Uint32* EndToken = StartToken + InstructionLength;
+    Uint32* StartToken = reinterpret_cast<Uint32*>(&Bytecode[StartTokenOffset]);
+    Uint32* EndToken   = StartToken + InstructionLength;
     VERIFY_EXPR(Token <= EndToken);
 
     RemapResourceBinding(Opcode, StartToken + 1, EndToken);
 
     Token = EndToken;
-
-    if (Token < Finish)
+    if (Token < GetChunkEnd())
     {
         const OpcodeToken& NextOpcode = reinterpret_cast<const OpcodeToken&>(*Token);
         VERIFY_EXPR(NextOpcode.OpcodeType < D3D10_SB_NUM_OPCODES);
@@ -1698,12 +1703,12 @@ void ShaderBytecodeRemapper::ParseOpcode(Uint32*& Token, const void* Finish)
 
 void ShaderBytecodeRemapper::PatchBytecode(const void* ChunkEnd) noexcept(false)
 {
-    VERIFY_EXPR(ChunkEnd == Bytecode.data() + EndOffset * 4);
+    VERIFY_EXPR(ChunkEnd == GetChunkEnd());
 
     Uint32* Token = reinterpret_cast<Uint32*>(&Bytecode[ChunkOffset + sizeof(ShaderChunkHeader)]);
-    for (; Token < ChunkEnd;)
+    while (Token < GetChunkEnd())
     {
-        ParseOpcode(Token, ChunkEnd);
+        ParseOpcode(Token);
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -986,7 +986,7 @@ struct ShaderBytecodeRemapper`
`986`	`986`
`987`	`987`	`IsSM51 = Header.VersionMajor == 5 && Header.VersionMinor >= 1;`
`988`	`988`
`989`		`- EndOffset = (ChunkOffset + sizeof(ChunkHeader) + Header.Length) / 4;`
	`989`	`+ EndOffset = ChunkOffset + sizeof(ChunkHeader) + Header.Length;`
`990`	`990`	`}`
`991`	`991`
`992`	`992`	`void PatchBytecode(const void* ChunkEnd) noexcept(false);`
`@@ -1004,29 +1004,34 @@ struct ShaderBytecodeRemapper`
`1004`	`1004`	`static constexpr Uint32 RuntimeSizedArraySize = ~0u;`
`1005`	`1005`
`1006`	`1006`	`private:`
`1007`		`- void RemapResourceOperand(const OperandToken& Operand, Uint32* Token, const void* Finish);`
`1008`		`- void RemapResourceOperandSM50(const OperandToken& Operand, Uint32* Token, const void* Finish);`
`1009`		`- void RemapResourceOperandSM51(const OperandToken& Operand, Uint32* Token, const void* Finish);`
	`1007`	`+ const Uint32* GetChunkEnd() const`
	`1008`	`+ {`
	`1009`	`+ return reinterpret_cast<const Uint32*>(Bytecode.data() + EndOffset);`
	`1010`	`+ }`
	`1011`	`+`
	`1012`	`+ void RemapResourceOperand(const OperandToken& Operand, Uint32* Token);`
	`1013`	`+ void RemapResourceOperandSM50(const OperandToken& Operand, Uint32* Token);`
	`1014`	`+ void RemapResourceOperandSM51(const OperandToken& Operand, Uint32* Token);`
`1010`	`1015`	`void RemapResourceOperandSM51_2(const OperandToken& Operand, Uint32* Token, RES_TYPE Type);`
`1011`	`1016`
`1012`	`1017`	`void RemapResourceBinding(const OpcodeToken& Opcode, Uint32* Token, const void* Finish);`
`1013`	`1018`	`void RemapResourceBindingSM51(const OpcodeToken& Opcode, Uint32* Token, const void* Finish);`
`1014`	`1019`
`1015`		`- void ParseOperand(Uint32& Token, const void Finish);`
`1016`		`- void ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION IndexType, Uint32& Token, const void Finish);`
`1017`		`- void ParseCustomData(Uint32& Token, const void Finish, D3D10_SB_CUSTOMDATA_CLASS Type);`
`1018`		`- void ParseOpcode(Uint32& Token, const void Finish);`
	`1020`	`+ void ParseOperand(Uint32*& Token);`
	`1021`	`+ void ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION IndexType, Uint32*& Token);`
	`1022`	`+ void ParseCustomData(Uint32*& Token, D3D10_SB_CUSTOMDATA_CLASS Type);`
	`1023`	`+ void ParseOpcode(Uint32*& Token);`
`1019`	`1024`	`};`
`1020`	`1025`
`1021`		`-void ShaderBytecodeRemapper::RemapResourceOperand(const OperandToken& Operand, Uint32* Token, const void* Finish)`
	`1026`	`+void ShaderBytecodeRemapper::RemapResourceOperand(const OperandToken& Operand, Uint32* Token)`
`1022`	`1027`	`{`
`1023`	`1028`	`if (IsSM51)`
`1024`	`1029`	`{`
`1025`		`- RemapResourceOperandSM51(Operand, Token, Finish);`
	`1030`	`+ RemapResourceOperandSM51(Operand, Token);`
`1026`	`1031`	`}`
`1027`	`1032`	`else`
`1028`	`1033`	`{`
`1029`		`- RemapResourceOperandSM50(Operand, Token, Finish);`
	`1034`	`+ RemapResourceOperandSM50(Operand, Token);`
`1030`	`1035`	`}`
`1031`	`1036`	`}`
`1032`	`1037`
`@@ -1038,7 +1043,7 @@ void ShaderBytecodeRemapper::RemapResourceBinding(const OpcodeToken& Opcode, Uin`
`1038`	`1043`	`}`
`1039`	`1044`	`}`
`1040`	`1045`
`1041`		`-void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operand, Uint32* Token, const void* Finish)`
	`1046`	`+void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operand, Uint32* Token)`
`1042`	`1047`	`{`
`1043`	`1048`	`const auto FindResourceBindings = [this](RES_TYPE Type, Uint32& Token) //`
`1044`	`1049`	`{`
`@@ -1063,7 +1068,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operan`
`1063`	`1068`	`// 0 - cbuffer bind point`
`1064`	`1069`	`// 1 - row offset (16 bytes per row) \| cbuffer size`
`1065`	`1070`
`1066`		`- VERIFY_EXPR(Token + 2 <= Finish);`
	`1071`	`+ VERIFY_EXPR(Token + 2 <= GetChunkEnd());`
`1067`	`1072`	`VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_2D);`
`1068`	`1073`	`VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);`
`1069`	`1074`	`VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);`
`@@ -1077,7 +1082,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operan`
`1077`	`1082`	`{`
`1078`	`1083`	`// 0 - sampler bind point`
`1079`	`1084`
`1080`		`- VERIFY_EXPR(Token + 1 <= Finish);`
	`1085`	`+ VERIFY_EXPR(Token + 1 <= GetChunkEnd());`
`1081`	`1086`	`VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_1D);`
`1082`	`1087`	`VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);`
`1083`	`1088`
`@@ -1090,7 +1095,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operan`
`1090`	`1095`	`{`
`1091`	`1096`	`// 0 - texture bind point`
`1092`	`1097`
`1093`		`- VERIFY_EXPR(Token + 1 <= Finish);`
	`1098`	`+ VERIFY_EXPR(Token + 1 <= GetChunkEnd());`
`1094`	`1099`	`VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_1D);`
`1095`	`1100`	`VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);`
`1096`	`1101`
`@@ -1103,7 +1108,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM50(const OperandToken& Operan`
`1103`	`1108`	`{`
`1104`	`1109`	`// 0 - UAV bind point`
`1105`	`1110`
`1106`		`- VERIFY_EXPR(Token + 1 <= Finish);`
	`1111`	`+ VERIFY_EXPR(Token + 1 <= GetChunkEnd());`
`1107`	`1112`	`VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_1D);`
`1108`	`1113`	`VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);`
`1109`	`1114`
`@@ -1157,7 +1162,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51_2(const OperandToken& Oper`
`1157`	`1162`	`}`
`1158`	`1163`	`}`
`1159`	`1164`
`1160`		`-void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operand, Uint32* Token, const void* Finish)`
	`1165`	`+void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operand, Uint32* Token)`
`1161`	`1166`	`{`
`1162`	`1167`	`switch (Operand.OperandType)`
`1163`	`1168`	`{`
`@@ -1167,7 +1172,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operan`
`1167`	`1172`	`// 1 - cbuffer bind point`
`1168`	`1173`	`// 2 - row offset (16 bytes per row)`
`1169`	`1174`
`1170`		`- VERIFY_EXPR(Token + 3 <= Finish);`
	`1175`	`+ VERIFY_EXPR(Token + 3 <= GetChunkEnd());`
`1171`	`1176`	`VERIFY_EXPR(Operand.IndexDim == D3D10_SB_OPERAND_INDEX_3D);`
`1172`	`1177`	`VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);`
`1173`	`1178`
`@@ -1180,7 +1185,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operan`
`1180`	`1185`	`// 0 - sampler index in resource definition`
`1181`	`1186`	`// 1 - sampler bind point`
`1182`	`1187`
`1183`		`- VERIFY_EXPR(Token + 2 <= Finish);`
	`1188`	`+ VERIFY_EXPR(Token + 2 <= GetChunkEnd());`
`1184`	`1189`	`VERIFY_EXPR(Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_2D);`
`1185`	`1190`	`VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);`
`1186`	`1191`
`@@ -1193,7 +1198,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operan`
`1193`	`1198`	`// 0 - texture index in resource definition`
`1194`	`1199`	`// 1 - texture bind point`
`1195`	`1200`
`1196`		`- VERIFY_EXPR(Token + 2 <= Finish);`
	`1201`	`+ VERIFY_EXPR(Token + 2 <= GetChunkEnd());`
`1197`	`1202`	`VERIFY_EXPR(Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_2D);`
`1198`	`1203`	`VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);`
`1199`	`1204`
`@@ -1206,7 +1211,7 @@ void ShaderBytecodeRemapper::RemapResourceOperandSM51(const OperandToken& Operan`
`1206`	`1211`	`// 0 - UAV index in resource definition`
`1207`	`1212`	`// 1 - UAV bind point`
`1208`	`1213`
`1209`		`- VERIFY_EXPR(Token + 2 <= Finish);`
	`1214`	`+ VERIFY_EXPR(Token + 2 <= GetChunkEnd());`
`1210`	`1215`	`VERIFY_EXPR(Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_2D);`
`1211`	`1216`	`VERIFY_EXPR(Operand.OperandIndex1D == D3D10_SB_OPERAND_INDEX_IMMEDIATE32);`
`1212`	`1217`
`@@ -1460,7 +1465,7 @@ void ShaderBytecodeRemapper::RemapResourceBindingSM51(const OpcodeToken& Opcode,`
`1460`	`1465`	`}`
`1461`	`1466`	`}`
`1462`	`1467`
`1463`		`-void ShaderBytecodeRemapper::ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION IndexType, Uint32& Token, const void Finish)`
	`1468`	`+void ShaderBytecodeRemapper::ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION IndexType, Uint32*& Token)`
`1464`	`1469`	`{`
`1465`	`1470`	`switch (IndexType)`
`1466`	`1471`	`{`
`@@ -1476,27 +1481,27 @@ void ShaderBytecodeRemapper::ParseIndex(D3D10_SB_OPERAND_INDEX_REPRESENTATION In`
`1476`	`1481`	`}`
`1477`	`1482`	`case D3D10_SB_OPERAND_INDEX_RELATIVE:`
`1478`	`1483`	`{`
`1479`		`- ParseOperand(Token, Finish);`
	`1484`	`+ ParseOperand(Token);`
`1480`	`1485`	`break;`
`1481`	`1486`	`}`
`1482`	`1487`	`case D3D10_SB_OPERAND_INDEX_IMMEDIATE32_PLUS_RELATIVE:`
`1483`	`1488`	`{`
`1484`	`1489`	`Token += 1;`
`1485`		`- ParseOperand(Token, Finish);`
	`1490`	`+ ParseOperand(Token);`
`1486`	`1491`	`break;`
`1487`	`1492`	`}`
`1488`	`1493`	`case D3D10_SB_OPERAND_INDEX_IMMEDIATE64_PLUS_RELATIVE:`
`1489`	`1494`	`{`
`1490`	`1495`	`Token += 2;`
`1491`		`- ParseOperand(Token, Finish);`
	`1496`	`+ ParseOperand(Token);`
`1492`	`1497`	`break;`
`1493`	`1498`	`}`
`1494`	`1499`	`default:`
`1495`	`1500`	`LOG_ERROR_AND_THROW("Unknown index type");`
`1496`	`1501`	`}`
`1497`	`1502`	`}`
`1498`	`1503`
`1499`		`-void ShaderBytecodeRemapper::ParseOperand(Uint32& Token, const void Finish)`
	`1504`	`+void ShaderBytecodeRemapper::ParseOperand(Uint32*& Token)`
`1500`	`1505`	`{`
`1501`	`1506`	`const OperandToken& Operand = reinterpret_cast<OperandToken>(Token++);`
`1502`	`1507`
`@@ -1567,7 +1572,7 @@ void ShaderBytecodeRemapper::ParseOperand(Uint32& Token, const void Finish)`
`1567`	`1572`	`case D3D10_SB_OPERAND_TYPE_CONSTANT_BUFFER:`
`1568`	`1573`	`case D3D10_SB_OPERAND_TYPE_IMMEDIATE_CONSTANT_BUFFER:`
`1569`	`1574`	`case D3D11_SB_OPERAND_TYPE_UNORDERED_ACCESS_VIEW:`
`1570`		`- RemapResourceOperand(Operand, Token, Finish);`
	`1575`	`+ RemapResourceOperand(Operand, Token);`
`1571`	`1576`	`break;`
`1572`	`1577`
`1573`	`1578`	`default:`
`@@ -1577,19 +1582,19 @@ void ShaderBytecodeRemapper::ParseOperand(Uint32& Token, const void Finish)`
`1577`	`1582`	`if (Operand.IndexDim != D3D10_SB_OPERAND_INDEX_0D)`
`1578`	`1583`	`{`
`1579`	`1584`	`if (Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_1D)`
`1580`		`- ParseIndex(Operand.OperandIndex1D, Token, Finish);`
	`1585`	`+ ParseIndex(Operand.OperandIndex1D, Token);`
`1581`	`1586`
`1582`	`1587`	`if (Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_2D)`
`1583`		`- ParseIndex(Operand.OperandIndex2D, Token, Finish);`
	`1588`	`+ ParseIndex(Operand.OperandIndex2D, Token);`
`1584`	`1589`
`1585`	`1590`	`if (Operand.IndexDim >= D3D10_SB_OPERAND_INDEX_3D)`
`1586`		`- ParseIndex(Operand.OperandIndex3D, Token, Finish);`
	`1591`	`+ ParseIndex(Operand.OperandIndex3D, Token);`
`1587`	`1592`	`}`
`1588`	`1593`
`1589`		`- VERIFY_EXPR(Token <= Finish);`
	`1594`	`+ VERIFY_EXPR(Token <= GetChunkEnd());`
`1590`	`1595`	`}`
`1591`	`1596`
`1592`		`-void ShaderBytecodeRemapper::ParseCustomData(Uint32& Token, const void Finish, D3D10_SB_CUSTOMDATA_CLASS Type)`
	`1597`	`+void ShaderBytecodeRemapper::ParseCustomData(Uint32*& Token, D3D10_SB_CUSTOMDATA_CLASS Type)`
`1593`	`1598`	`{`
`1594`	`1599`	`switch (Type)`
`1595`	`1600`	`{`
`@@ -1605,14 +1610,14 @@ void ShaderBytecodeRemapper::ParseCustomData(Uint32& Token, const void Finish,`
`1605`	`1610`	`}`
`1606`	`1611`	`}`
`1607`	`1612`
`1608`		`-void ShaderBytecodeRemapper::ParseOpcode(Uint32& Token, const void Finish)`
	`1613`	`+void ShaderBytecodeRemapper::ParseOpcode(Uint32*& Token)`
`1609`	`1614`	`{`
`1610`	`1615`	`// based on code from`
`1611`	`1616`	`// https://github.com/microsoft/D3D12TranslationLayer/blob/master/src/ShaderBinary.cpp`
`1612`	`1617`	`// Copyright (c) Microsoft Corporation.`
`1613`	`1618`	`// MIT License`
`1614`	`1619`
`1615`		`- Uint32* StartToken = Token;`
	`1620`	`+ const ptrdiff_t StartTokenOffset = reinterpret_cast<const Uint8*>(Token) - Bytecode.data();`
`1616`	`1621`	`const OpcodeToken Opcode = reinterpret_cast<OpcodeToken&>(*Token++);`
`1617`	`1622`	`const Uint32 NumOperands = GetNumOperands(Opcode.OpcodeType);`
`1618`	`1623`	`Uint32 InstructionLength = Opcode.OpcodeLength;`
`@@ -1646,7 +1651,7 @@ void ShaderBytecodeRemapper::ParseOpcode(Uint32& Token, const void Finish)`
`1646`	`1651`	`InstructionLength = *Token;`
`1647`	`1652`	`VERIFY_EXPR(InstructionLength >= 2);`
`1648`	`1653`
`1649`		`- ParseCustomData(Token, Finish, Type);`
	`1654`	`+ ParseCustomData(Token, Type);`
`1650`	`1655`	`break;`
`1651`	`1656`	`}`
`1652`	`1657`
`@@ -1678,18 +1683,18 @@ void ShaderBytecodeRemapper::ParseOpcode(Uint32& Token, const void Finish)`
`1678`	`1683`
`1679`	`1684`	`default:`
`1680`	`1685`	`for (Uint32 i = 0; i < NumOperands; ++i)`
`1681`		`- ParseOperand(Token, Finish);`
	`1686`	`+ ParseOperand(Token);`
`1682`	`1687`	`break;`
`1683`	`1688`	`}`
`1684`	`1689`
`1685`		`- Uint32* EndToken = StartToken + InstructionLength;`
	`1690`	`+ Uint32* StartToken = reinterpret_cast<Uint32*>(&Bytecode[StartTokenOffset]);`
	`1691`	`+ Uint32* EndToken = StartToken + InstructionLength;`
`1686`	`1692`	`VERIFY_EXPR(Token <= EndToken);`
`1687`	`1693`
`1688`	`1694`	`RemapResourceBinding(Opcode, StartToken + 1, EndToken);`
`1689`	`1695`
`1690`	`1696`	`Token = EndToken;`
`1691`		`-`
`1692`		`- if (Token < Finish)`
	`1697`	`+ if (Token < GetChunkEnd())`
`1693`	`1698`	`{`
`1694`	`1699`	`const OpcodeToken& NextOpcode = reinterpret_cast<const OpcodeToken&>(*Token);`
`1695`	`1700`	`VERIFY_EXPR(NextOpcode.OpcodeType < D3D10_SB_NUM_OPCODES);`
`@@ -1698,12 +1703,12 @@ void ShaderBytecodeRemapper::ParseOpcode(Uint32& Token, const void Finish)`
`1698`	`1703`
`1699`	`1704`	`void ShaderBytecodeRemapper::PatchBytecode(const void* ChunkEnd) noexcept(false)`
`1700`	`1705`	`{`
`1701`		`- VERIFY_EXPR(ChunkEnd == Bytecode.data() + EndOffset * 4);`
	`1706`	`+ VERIFY_EXPR(ChunkEnd == GetChunkEnd());`
`1702`	`1707`
`1703`	`1708`	`Uint32* Token = reinterpret_cast<Uint32*>(&Bytecode[ChunkOffset + sizeof(ShaderChunkHeader)]);`
`1704`		`- for (; Token < ChunkEnd;)`
	`1709`	`+ while (Token < GetChunkEnd())`
`1705`	`1710`	`{`
`1706`		`- ParseOpcode(Token, ChunkEnd);`
	`1711`	`+ ParseOpcode(Token);`
`1707`	`1712`	`}`
`1708`	`1713`	`}`
`1709`	`1714`