Separate Dot instrinsic tests (#2247)

tools/clang/unittests/HLSL/ExecutionTest.cpp

@@ -403,6 +403,18 @@ public:
     TEST_METHOD_PROPERTY(L"DataSource", L"Table:ShaderOpArithTable.xml#DotOpTable")
   END_TEST_METHOD()
 
+  BEGIN_TEST_METHOD(Dot2AddHalfTest)
+    TEST_METHOD_PROPERTY(L"DataSource", L"Table:ShaderOpArithTable.xml#Dot2AddHalfOpTable")
+  END_TEST_METHOD()
+
+  BEGIN_TEST_METHOD(Dot4AddI8PackedTest)
+    TEST_METHOD_PROPERTY(L"DataSource", L"Table:ShaderOpArithTable.xml#Dot4AddI8PackedOpTable")
+  END_TEST_METHOD()
+
+  BEGIN_TEST_METHOD(Dot4AddU8PackedTest)
+    TEST_METHOD_PROPERTY(L"DataSource", L"Table:ShaderOpArithTable.xml#Dot4AddU8PackedOpTable")
+  END_TEST_METHOD()
+
   BEGIN_TEST_METHOD(Msad4Test)
     TEST_METHOD_PROPERTY(L"DataSource", L"Table:ShaderOpArithTable.xml#Msad4Table")
   END_TEST_METHOD()
@@ -521,11 +533,6 @@ public:
 
   void RunBasicShaderModelTest(D3D_SHADER_MODEL shaderModel);
 
-  void RunDotOp();
-  void RunDot2AddOp();
-  void RunDot4AddI8PackedOp();
-  void RunDot4AddU8PackedOp();
-
   enum class RawBufferLdStType {
      I32,
      Float,
@@ -2774,7 +2781,7 @@ struct Half2
     explicit Half2(_In_reads_(2) const uint16_t *pArray) : x(pArray[0]), y(pArray[1]) {}
 };
 
-struct SDot2AddOp {
+struct SDot2AddHalfOp {
     Half2 input1;
     Half2 input2;
     float acc;
@@ -3163,45 +3170,45 @@ static TableParameter TertiaryUint16OpParameters[] = {
 };
 
 static TableParameter DotOpParameters[] = {
-    { L"Dot.ShaderOp.Target", TableParameter::STRING, true },
-    { L"Dot.ShaderOp.Text", TableParameter::STRING, true },
-    { L"Dot.Validation.Input1", TableParameter::STRING_TABLE, true },
-    { L"Dot.Validation.Input2", TableParameter::STRING_TABLE, true },
-    { L"Dot.Validation.Expected1", TableParameter::STRING_TABLE, true },
-    { L"Dot.Validation.Expected2", TableParameter::STRING_TABLE, true },
-    { L"Dot.Validation.Expected3", TableParameter::STRING_TABLE, true },
-    { L"Dot.Validation.Type", TableParameter::STRING, true },
-    { L"Dot.Validation.Tolerance", TableParameter::DOUBLE, true },
+    { L"ShaderOp.Target", TableParameter::STRING, true },
+    { L"ShaderOp.Text", TableParameter::STRING, true },
+    { L"Validation.Input1", TableParameter::STRING_TABLE, true },
+    { L"Validation.Input2", TableParameter::STRING_TABLE, true },
+    { L"Validation.Expected1", TableParameter::STRING_TABLE, true },
+    { L"Validation.Expected2", TableParameter::STRING_TABLE, true },
+    { L"Validation.Expected3", TableParameter::STRING_TABLE, true },
+    { L"Validation.Type", TableParameter::STRING, true },
+    { L"Validation.Tolerance", TableParameter::DOUBLE, true },
 };
 
-static TableParameter Dot2AddOpParameters[] = {
-    { L"Dot2Add.ShaderOp.Target", TableParameter::STRING, true },
-    { L"Dot2Add.ShaderOp.Text", TableParameter::STRING, true },
-    { L"Dot2Add.ShaderOp.Arguments", TableParameter::STRING, true },
-    { L"Dot2Add.Validation.Input1", TableParameter::STRING_TABLE, true },
-    { L"Dot2Add.Validation.Input2", TableParameter::STRING_TABLE, true },
-    { L"Dot2Add.Validation.Input3", TableParameter::FLOAT_TABLE, true },
-    { L"Dot2Add.Validation.Expected1", TableParameter::FLOAT_TABLE, true },
-    { L"Dot2Add.Validation.Type", TableParameter::STRING, true },
-    { L"Dot2Add.Validation.Tolerance", TableParameter::DOUBLE, true },
+static TableParameter Dot2AddHalfOpParameters[] = {
+    { L"ShaderOp.Target", TableParameter::STRING, true },
+    { L"ShaderOp.Text", TableParameter::STRING, true },
+    { L"ShaderOp.Arguments", TableParameter::STRING, true },
+    { L"Validation.Input1", TableParameter::STRING_TABLE, true },
+    { L"Validation.Input2", TableParameter::STRING_TABLE, true },
+    { L"Validation.Input3", TableParameter::FLOAT_TABLE, true },
+    { L"Validation.Expected1", TableParameter::FLOAT_TABLE, true },
+    { L"Validation.Type", TableParameter::STRING, true },
+    { L"Validation.Tolerance", TableParameter::DOUBLE, true },
 };
 
 static TableParameter Dot4AddI8PackedOpParameters[] = {
-    { L"Dot4AddI8Packed.ShaderOp.Target", TableParameter::STRING, true },
-    { L"Dot4AddI8Packed.ShaderOp.Text", TableParameter::STRING, true },
-    { L"Dot4AddI8Packed.Validation.Input1", TableParameter::UINT32_TABLE, true },
-    { L"Dot4AddI8Packed.Validation.Input2", TableParameter::UINT32_TABLE, true },
-    { L"Dot4AddI8Packed.Validation.Input3", TableParameter::INT32_TABLE, true },
-    { L"Dot4AddI8Packed.Validation.Expected1", TableParameter::INT32_TABLE, true },
+    { L"ShaderOp.Target", TableParameter::STRING, true },
+    { L"ShaderOp.Text", TableParameter::STRING, true },
+    { L"Validation.Input1", TableParameter::UINT32_TABLE, true },
+    { L"Validation.Input2", TableParameter::UINT32_TABLE, true },
+    { L"Validation.Input3", TableParameter::INT32_TABLE, true },
+    { L"Validation.Expected1", TableParameter::INT32_TABLE, true },
 };
 
 static TableParameter Dot4AddU8PackedOpParameters[] = {
-    { L"Dot4AddU8Packed.ShaderOp.Target", TableParameter::STRING, true },
-    { L"Dot4AddU8Packed.ShaderOp.Text", TableParameter::STRING, true },
-    { L"Dot4AddU8Packed.Validation.Input1", TableParameter::UINT32_TABLE, true },
-    { L"Dot4AddU8Packed.Validation.Input2", TableParameter::UINT32_TABLE, true },
-    { L"Dot4AddU8Packed.Validation.Input3", TableParameter::UINT32_TABLE, true },
-    { L"Dot4AddU8Packed.Validation.Expected1", TableParameter::UINT32_TABLE, true },
+    { L"ShaderOp.Target", TableParameter::STRING, true },
+    { L"ShaderOp.Text", TableParameter::STRING, true },
+    { L"Validation.Input1", TableParameter::UINT32_TABLE, true },
+    { L"Validation.Input2", TableParameter::UINT32_TABLE, true },
+    { L"Validation.Input3", TableParameter::UINT32_TABLE, true },
+    { L"Validation.Expected1", TableParameter::UINT32_TABLE, true },
 };
 
 static TableParameter Msad4OpParameters[] = {
@@ -5064,18 +5071,7 @@ TEST_F(ExecutionTest, TertiaryUint16OpTest) {
   }
 }
 
-// TODO: Split into 4 different tests after 19H1 when we're allowed to add new tests
 TEST_F(ExecutionTest, DotTest) {
-    RunDotOp();
-    RunDot2AddOp();
-    RunDot4AddI8PackedOp();
-    RunDot4AddU8PackedOp();
-}
-
-// Helper for the Dot operator, which is part of DotTest
-void ExecutionTest::RunDotOp() {
-    WEX::Logging::Log::Comment(L"\nRunning Dot Op tests:\n");
-
     WEX::TestExecution::SetVerifyOutput verifySettings(
         WEX::TestExecution::VerifyOutputSettings::LogOnlyFailures);
     CComPtr<IStream> pStream;
@@ -5089,22 +5085,22 @@ void ExecutionTest::RunDotOp() {
     int tableSize = sizeof(DotOpParameters) / sizeof(TableParameter);
     TableParameterHandler handler(DotOpParameters, tableSize);
 
-    CW2A Target(handler.GetTableParamByName(L"Dot.ShaderOp.Target")->m_str);
-    CW2A Text(handler.GetTableParamByName(L"Dot.ShaderOp.Text")->m_str);
+    CW2A Target(handler.GetTableParamByName(L"ShaderOp.Target")->m_str);
+    CW2A Text(handler.GetTableParamByName(L"ShaderOp.Text")->m_str);
 
     std::vector<WEX::Common::String> *Validation_Input1 =
-        &handler.GetTableParamByName(L"Dot.Validation.Input1")->m_StringTable;
+        &handler.GetTableParamByName(L"Validation.Input1")->m_StringTable;
     std::vector<WEX::Common::String> *Validation_Input2 =
-        &handler.GetTableParamByName(L"Dot.Validation.Input2")->m_StringTable;
+        &handler.GetTableParamByName(L"Validation.Input2")->m_StringTable;
     std::vector<WEX::Common::String> *Validation_dot2 =
-        &handler.GetTableParamByName(L"Dot.Validation.Expected1")->m_StringTable;
+        &handler.GetTableParamByName(L"Validation.Expected1")->m_StringTable;
     std::vector<WEX::Common::String> *Validation_dot3 =
-        &handler.GetTableParamByName(L"Dot.Validation.Expected2")->m_StringTable;
+        &handler.GetTableParamByName(L"Validation.Expected2")->m_StringTable;
     std::vector<WEX::Common::String> *Validation_dot4 =
-        &handler.GetTableParamByName(L"Dot.Validation.Expected3")->m_StringTable;
+        &handler.GetTableParamByName(L"Validation.Expected3")->m_StringTable;
 
-    PCWSTR Validation_type = handler.GetTableParamByName(L"Dot.Validation.Type")->m_str;
-    double tolerance = handler.GetTableParamByName(L"Dot.Validation.Tolerance")->m_double;
+    PCWSTR Validation_type = handler.GetTableParamByName(L"Validation.Type")->m_str;
+    double tolerance = handler.GetTableParamByName(L"Validation.Tolerance")->m_double;
     size_t count = Validation_Input1->size();
 
     std::shared_ptr<ShaderOpTestResult> test = RunShaderOpTest(
@@ -5158,10 +5154,7 @@ void ExecutionTest::RunDotOp() {
     }
 }
 
-// Helper for the Dot2Add operator, which is part of DotTest
-void ExecutionTest::RunDot2AddOp() {
-    WEX::Logging::Log::Comment(L"\nRunning Dot2Add Op tests:\n");
-
+TEST_F(ExecutionTest, Dot2AddHalfTest) {
     WEX::TestExecution::SetVerifyOutput verifySettings(
         WEX::TestExecution::VerifyOutputSettings::LogOnlyFailures);
     CComPtr<IStream> pStream;
@@ -5174,40 +5167,39 @@ void ExecutionTest::RunDot2AddOp() {
 
     if (!DoesDeviceSupportNative16bitOps(pDevice)) {
         WEX::Logging::Log::Comment(L"Device does not support native 16-bit operations.");
-        // Don't skip this test for now, otherwise the entire DotTest would be skipped
-        // TODO: Skip the test once the Dot tests have been split in 4 different tests
+        WEX::Logging::Log::Result(WEX::Logging::TestResults::Skipped);
         return;
     }
 
-    int tableSize = sizeof(Dot2AddOpParameters) / sizeof(TableParameter);
-    TableParameterHandler handler(Dot2AddOpParameters, tableSize);
+    int tableSize = sizeof(Dot2AddHalfOpParameters) / sizeof(TableParameter);
+    TableParameterHandler handler(Dot2AddHalfOpParameters, tableSize);
 
-    CW2A Target(handler.GetTableParamByName(L"Dot2Add.ShaderOp.Target")->m_str);
-    CW2A Text(handler.GetTableParamByName(L"Dot2Add.ShaderOp.Text")->m_str);
-    CW2A Arguments(handler.GetTableParamByName(L"Dot2Add.ShaderOp.Arguments")->m_str);
+    CW2A Target(handler.GetTableParamByName(L"ShaderOp.Target")->m_str);
+    CW2A Text(handler.GetTableParamByName(L"ShaderOp.Text")->m_str);
+    CW2A Arguments(handler.GetTableParamByName(L"ShaderOp.Arguments")->m_str);
 
     std::vector<WEX::Common::String> *validation_input1 =
-        &handler.GetTableParamByName(L"Dot2Add.Validation.Input1")->m_StringTable;
+        &handler.GetTableParamByName(L"Validation.Input1")->m_StringTable;
     std::vector<WEX::Common::String> *validation_input2 =
-        &handler.GetTableParamByName(L"Dot2Add.Validation.Input2")->m_StringTable;
-    std::vector<float> *validation_acc = &handler.GetTableParamByName(L"Dot2Add.Validation.Input3")->m_floatTable;
-    std::vector<float> *validation_result = &handler.GetTableParamByName(L"Dot2Add.Validation.Expected1")->m_floatTable;
+        &handler.GetTableParamByName(L"Validation.Input2")->m_StringTable;
+    std::vector<float> *validation_acc = &handler.GetTableParamByName(L"Validation.Input3")->m_floatTable;
+    std::vector<float> *validation_result = &handler.GetTableParamByName(L"Validation.Expected1")->m_floatTable;
 
-    PCWSTR Validation_type = handler.GetTableParamByName(L"Dot2Add.Validation.Type")->m_str;
-    double tolerance = handler.GetTableParamByName(L"Dot2Add.Validation.Tolerance")->m_double;
+    PCWSTR Validation_type = handler.GetTableParamByName(L"Validation.Type")->m_str;
+    double tolerance = handler.GetTableParamByName(L"Validation.Tolerance")->m_double;
     size_t count = validation_input1->size();
 
     std::shared_ptr<ShaderOpTestResult> test = RunShaderOpTest(
-        pDevice, m_support, pStream, "Dot2AddOp",
+        pDevice, m_support, pStream, "Dot2AddHalfOp",
         // this callback is called when the test
         // is creating the resource to run the test
         [&](LPCSTR Name, std::vector<BYTE> &Data, st::ShaderOp *pShaderOp) {
-        VERIFY_IS_TRUE(0 == _stricmp(Name, "SDot2AddOp"));
-        size_t size = sizeof(SDot2AddOp) * count;
+        VERIFY_IS_TRUE(0 == _stricmp(Name, "SDot2AddHalfOp"));
+        size_t size = sizeof(SDot2AddHalfOp) * count;
         Data.resize(size);
-        SDot2AddOp *pPrimitives = (SDot2AddOp*)Data.data();
+        SDot2AddHalfOp *pPrimitives = (SDot2AddHalfOp*)Data.data();
         for (size_t i = 0; i < count; ++i) {
-            SDot2AddOp *p = &pPrimitives[i];
+            SDot2AddHalfOp *p = &pPrimitives[i];
             Half2 val1,val2;
             VERIFY_SUCCEEDED(ParseDataToVectorHalf((*validation_input1)[i],
                                                     (uint16_t *)&val1, 2));
@@ -5224,12 +5216,12 @@ void ExecutionTest::RunDot2AddOp() {
     });
 
     MappedData data;
-    test->Test->GetReadBackData("SDot2AddOp", &data);
+    test->Test->GetReadBackData("SDot2AddHalfOp", &data);
 
-    SDot2AddOp *pPrimitives = (SDot2AddOp*)data.data();
+    SDot2AddHalfOp *pPrimitives = (SDot2AddHalfOp*)data.data();
     WEX::TestExecution::DisableVerifyExceptions dve;
     for (size_t i = 0; i < count; ++i) {
-        SDot2AddOp *p = &pPrimitives[i];
+        SDot2AddHalfOp *p = &pPrimitives[i];
         float expectedResult = (*validation_result)[i];
         float input1x = ConvertFloat16ToFloat32(p->input1.x);
         float input1y = ConvertFloat16ToFloat32(p->input1.y);
@@ -5243,10 +5235,7 @@ void ExecutionTest::RunDot2AddOp() {
     }
 }
 
-// Helper for the Dot4AddI8Packed operator, which is part of DotTest
-void ExecutionTest::RunDot4AddI8PackedOp() {
-    WEX::Logging::Log::Comment(L"\nRunning Dot4AddI8Packed Op tests:\n");
-
+TEST_F(ExecutionTest, Dot4AddI8PackedTest) {
     WEX::TestExecution::SetVerifyOutput verifySettings(
         WEX::TestExecution::VerifyOutputSettings::LogOnlyFailures);
     CComPtr<IStream> pStream;
@@ -5260,13 +5249,13 @@ void ExecutionTest::RunDot4AddI8PackedOp() {
     int tableSize = sizeof(Dot4AddI8PackedOpParameters) / sizeof(TableParameter);
     TableParameterHandler handler(Dot4AddI8PackedOpParameters, tableSize);
 
-    CW2A Target(handler.GetTableParamByName(L"Dot4AddI8Packed.ShaderOp.Target")->m_str);
-    CW2A Text(handler.GetTableParamByName(L"Dot4AddI8Packed.ShaderOp.Text")->m_str);
+    CW2A Target(handler.GetTableParamByName(L"ShaderOp.Target")->m_str);
+    CW2A Text(handler.GetTableParamByName(L"ShaderOp.Text")->m_str);
 
-    std::vector<uint32_t> *validation_input1 = &handler.GetTableParamByName(L"Dot4AddI8Packed.Validation.Input1")->m_uint32Table;
-    std::vector<uint32_t> *validation_input2 = &handler.GetTableParamByName(L"Dot4AddI8Packed.Validation.Input2")->m_uint32Table;
-    std::vector<int32_t> *validation_acc = &handler.GetTableParamByName(L"Dot4AddI8Packed.Validation.Input3")->m_int32Table;
-    std::vector<int32_t> *validation_result = &handler.GetTableParamByName(L"Dot4AddI8Packed.Validation.Expected1")->m_int32Table;
+    std::vector<uint32_t> *validation_input1 = &handler.GetTableParamByName(L"Validation.Input1")->m_uint32Table;
+    std::vector<uint32_t> *validation_input2 = &handler.GetTableParamByName(L"Validation.Input2")->m_uint32Table;
+    std::vector<int32_t> *validation_acc = &handler.GetTableParamByName(L"Validation.Input3")->m_int32Table;
+    std::vector<int32_t> *validation_result = &handler.GetTableParamByName(L"Validation.Expected1")->m_int32Table;
 
     size_t count = validation_input1->size();
 
@@ -5306,10 +5295,7 @@ void ExecutionTest::RunDot4AddI8PackedOp() {
     }
 }
 
-// Helper for the Dot4AddU8Packed operator, which is part of DotTest
-void ExecutionTest::RunDot4AddU8PackedOp() {
-    WEX::Logging::Log::Comment(L"\nRunning Dot4AddU8Packed Op tests\n");
-
+TEST_F(ExecutionTest, Dot4AddU8PackedTest) {
     WEX::TestExecution::SetVerifyOutput verifySettings(
         WEX::TestExecution::VerifyOutputSettings::LogOnlyFailures);
     CComPtr<IStream> pStream;
@@ -5323,13 +5309,13 @@ void ExecutionTest::RunDot4AddU8PackedOp() {
     int tableSize = sizeof(Dot4AddU8PackedOpParameters) / sizeof(TableParameter);
     TableParameterHandler handler(Dot4AddU8PackedOpParameters, tableSize);
 
-    CW2A Target(handler.GetTableParamByName(L"Dot4AddU8Packed.ShaderOp.Target")->m_str);
-    CW2A Text(handler.GetTableParamByName(L"Dot4AddU8Packed.ShaderOp.Text")->m_str);
+    CW2A Target(handler.GetTableParamByName(L"ShaderOp.Target")->m_str);
+    CW2A Text(handler.GetTableParamByName(L"ShaderOp.Text")->m_str);
 
-    std::vector<uint32_t> *validation_input1 = &handler.GetTableParamByName(L"Dot4AddU8Packed.Validation.Input1")->m_uint32Table;
-    std::vector<uint32_t> *validation_input2 = &handler.GetTableParamByName(L"Dot4AddU8Packed.Validation.Input2")->m_uint32Table;
-    std::vector<uint32_t> *validation_acc = &handler.GetTableParamByName(L"Dot4AddU8Packed.Validation.Input3")->m_uint32Table;
-    std::vector<uint32_t> *validation_result = &handler.GetTableParamByName(L"Dot4AddU8Packed.Validation.Expected1")->m_uint32Table;
+    std::vector<uint32_t> *validation_input1 = &handler.GetTableParamByName(L"Validation.Input1")->m_uint32Table;
+    std::vector<uint32_t> *validation_input2 = &handler.GetTableParamByName(L"Validation.Input2")->m_uint32Table;
+    std::vector<uint32_t> *validation_acc = &handler.GetTableParamByName(L"Validation.Input3")->m_uint32Table;
+    std::vector<uint32_t> *validation_result = &handler.GetTableParamByName(L"Validation.Expected1")->m_uint32Table;
 
     size_t count = validation_input1->size();
 

tools/clang/unittests/HLSL/ShaderOpArithTable.xml

@@ -4750,53 +4750,23 @@
             <Parameter Name="ShaderOp.Arguments">-enable-16bit-types</Parameter>
         </Row>
     </Table>
-    <!-- TODO: Split into 4 separate tables after 19H1 -->
     <Table Id="DotOpTable">
         <ParameterTypes>
-            <!-- DotAdd Parameters -->
-            <ParameterType Name="Dot.ShaderOp.Target">String</ParameterType>
-            <ParameterType Name="Dot.ShaderOp.Arguments">String</ParameterType>
-            <ParameterType Name="Dot.ShaderOp.Text">String</ParameterType>
-            <ParameterType Name="Dot.Validation.Type">String</ParameterType>
-            <ParameterType Name="Dot.Validation.Tolerance">double</ParameterType>
-            <ParameterType Array="true" Name="Dot.Validation.Input1">String</ParameterType>
-            <ParameterType Array="true" Name="Dot.Validation.Input2">String</ParameterType>
-            <ParameterType Array="true" Name="Dot.Validation.Expected1">String</ParameterType>
-            <ParameterType Array="true" Name="Dot.Validation.Expected2">String</ParameterType>
-            <ParameterType Array="true" Name="Dot.Validation.Expected3">String</ParameterType>
-
-            <!-- Dot2Add Parameters -->
-            <ParameterType Name="Dot2Add.ShaderOp.Target">String</ParameterType>
-            <ParameterType Name="Dot2Add.ShaderOp.Arguments">String</ParameterType>
-            <ParameterType Name="Dot2Add.ShaderOp.Text">String</ParameterType>
-            <ParameterType Name="Dot2Add.Validation.Type">String</ParameterType>
-            <ParameterType Name="Dot2Add.Validation.Tolerance">double</ParameterType>
-            <ParameterType Array="true" Name="Dot2Add.Validation.Input1">String</ParameterType>
-            <ParameterType Array="true" Name="Dot2Add.Validation.Input2">String</ParameterType>
-            <ParameterType Array="true" Name="Dot2Add.Validation.Input3">String</ParameterType>
-            <ParameterType Array="true" Name="Dot2Add.Validation.Expected1">String</ParameterType>
-
-            <!-- Dot4AddI8Packed Parameters -->
-            <ParameterType Name="Dot4AddI8Packed.ShaderOp.Target">String</ParameterType>
-            <ParameterType Name="Dot4AddI8Packed.ShaderOp.Text">String</ParameterType>
-            <ParameterType Array="true" Name="Dot4AddI8Packed.Validation.Input1">String</ParameterType>
-            <ParameterType Array="true" Name="Dot4AddI8Packed.Validation.Input2">String</ParameterType>
-            <ParameterType Array="true" Name="Dot4AddI8Packed.Validation.Input3">String</ParameterType>
-            <ParameterType Array="true" Name="Dot4AddI8Packed.Validation.Expected1">String</ParameterType>
-
-            <!-- Dot4AddU8Packed Parameters -->
-            <ParameterType Name="Dot4AddU8Packed.ShaderOp.Target">String</ParameterType>
-            <ParameterType Name="Dot4AddU8Packed.ShaderOp.Text">String</ParameterType>
-            <ParameterType Array="true" Name="Dot4AddU8Packed.Validation.Input1">String</ParameterType>
-            <ParameterType Array="true" Name="Dot4AddU8Packed.Validation.Input2">String</ParameterType>
-            <ParameterType Array="true" Name="Dot4AddU8Packed.Validation.Input3">String</ParameterType>
-            <ParameterType Array="true" Name="Dot4AddU8Packed.Validation.Expected1">String</ParameterType>
+            <ParameterType Name="ShaderOp.Target">String</ParameterType>
+            <ParameterType Name="ShaderOp.Arguments">String</ParameterType>
+            <ParameterType Name="ShaderOp.Text">String</ParameterType>
+            <ParameterType Name="Validation.Type">String</ParameterType>
+            <ParameterType Name="Validation.Tolerance">double</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input1">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input2">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Expected1">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Expected2">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Expected3">String</ParameterType>
         </ParameterTypes>
         <Row Name="Dot">
-            <!-- Dot Parameters -->
-            <Parameter Name="Dot.Validation.Type">epsilon</Parameter>
-            <Parameter Name="Dot.Validation.Tolerance">0.008</Parameter>
-            <Parameter Name="Dot.ShaderOp.Text"> struct SDotOp {
+            <Parameter Name="Validation.Type">epsilon</Parameter>
+            <Parameter Name="Validation.Tolerance">0.008</Parameter>
+            <Parameter Name="ShaderOp.Text"> struct SDotOp {
                    float4 input1;
                    float4 input2;
                    float o_dot2;
@@ -4812,8 +4782,8 @@
                     l.o_dot4 = dot(l.input1.xyzw, l.input2.xyzw);
                     g_buf[GI] = l;
                 };</Parameter>
-            <Parameter Name="Dot.ShaderOp.Target">cs_6_0</Parameter>
-            <Parameter Name="Dot.Validation.Input1">
+            <Parameter Name="ShaderOp.Target">cs_6_0</Parameter>
+            <Parameter Name="Validation.Input1">
                 <Value>NaN,NaN,NaN,NaN</Value>
                 <Value>-Inf,-Inf,-Inf,-Inf</Value>
                 <Value>-denorm,-denorm,-denorm,-denorm</Value>
@@ -4825,7 +4795,7 @@
                 <Value>-10,0,0,10</Value>
                 <Value>Inf,Inf,Inf,-Inf</Value>
             </Parameter>
-            <Parameter Name="Dot.Validation.Input2">
+            <Parameter Name="Validation.Input2">
                 <Value>NaN,NaN,NaN,NaN</Value>
                 <Value>-Inf,-Inf,-Inf,-Inf</Value>
                 <Value>-denorm,-denorm,-denorm,-denorm</Value>
@@ -4837,7 +4807,7 @@
                 <Value>10,0,0,10</Value>
                 <Value>Inf,Inf,Inf,Inf</Value>
             </Parameter>
-            <Parameter Name="Dot.Validation.Expected1">
+            <Parameter Name="Validation.Expected1">
                 <Value>nan</Value>
                 <Value>inf</Value>
                 <Value>0</Value>
@@ -4849,7 +4819,7 @@
                 <Value>-100</Value>
                 <Value>inf</Value>
             </Parameter>
-            <Parameter Name="Dot.Validation.Expected2">
+            <Parameter Name="Validation.Expected2">
                 <Value>nan</Value>
                 <Value>inf</Value>
                 <Value>0</Value>
@@ -4861,7 +4831,7 @@
                 <Value>-100</Value>
                 <Value>inf</Value>
             </Parameter>
-            <Parameter Name="Dot.Validation.Expected3">
+            <Parameter Name="Validation.Expected3">
                 <Value>nan</Value>
                 <Value>inf</Value>
                 <Value>0</Value>
@@ -4873,25 +4843,38 @@
                 <Value>0</Value>
                 <Value>nan</Value>
             </Parameter>
-
-            <!-- Dot2Add Parameters -->
-            <Parameter Name="Dot2Add.Validation.Type">epsilon</Parameter>
-            <Parameter Name="Dot2Add.Validation.Tolerance">0.008</Parameter>
-            <Parameter Name="Dot2Add.ShaderOp.Text"> struct SDot2AddOp {
+        </Row>
+    </Table>
+    <Table Id="Dot2AddHalfOpTable">
+        <ParameterTypes>
+            <ParameterType Name="ShaderOp.Target">String</ParameterType>
+            <ParameterType Name="ShaderOp.Arguments">String</ParameterType>
+            <ParameterType Name="ShaderOp.Text">String</ParameterType>
+            <ParameterType Name="Validation.Type">String</ParameterType>
+            <ParameterType Name="Validation.Tolerance">double</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input1">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input2">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input3">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Expected1">String</ParameterType>
+        </ParameterTypes>
+        <Row Name="Dot2AddHalf">
+            <Parameter Name="Validation.Type">epsilon</Parameter>
+            <Parameter Name="Validation.Tolerance">0.008</Parameter>
+            <Parameter Name="ShaderOp.Text"> struct SDot2AddHalfOp {
                    half2 input1;
                    half2 input2;
                    float acc;
                    float result;
                 };
-                RWStructuredBuffer&lt;SDot2AddOp&gt; g_buf : register(u0);
+                RWStructuredBuffer&lt;SDot2AddHalfOp&gt; g_buf : register(u0);
                 [numthreads(8,8,1)]
                 void main(uint GI : SV_GroupIndex) {
-                    SDot2AddOp l = g_buf[GI];
+                    SDot2AddHalfOp l = g_buf[GI];
                     l.result = dot2add(l.input1, l.input2, l.acc);
                     g_buf[GI] = l;
                 };</Parameter>
-            <Parameter Name="Dot2Add.ShaderOp.Target">cs_6_4</Parameter>
-            <Parameter Name="Dot2Add.Validation.Input1">
+            <Parameter Name="ShaderOp.Target">cs_6_4</Parameter>
+            <Parameter Name="Validation.Input1">
                 <Value>1,2</Value>
                 <Value>1,-2</Value>
                 <Value>1,2</Value>
@@ -4904,13 +4887,12 @@
                 <Value>-65504,1</Value>
                 <Value>1,65504</Value>
                 <Value>1,-65504</Value>
-                <Value>65504,65504</Value>
                 <Value>inf,inf</Value>
                 <Value>denorm,denorm</Value>
                 <Value>-denorm,-denorm</Value>
                 <Value>nan,nan</Value>
             </Parameter>
-            <Parameter Name="Dot2Add.Validation.Input2">
+            <Parameter Name="Validation.Input2">
                 <Value>3,4</Value>
                 <Value>-3,4</Value>
                 <Value>3,4</Value>
@@ -4923,13 +4905,12 @@
                 <Value>1,-65504</Value>
                 <Value>65504,1</Value>
                 <Value>-65504,1</Value>
-                <Value>65504,65504</Value>
                 <Value>inf,inf</Value>
                 <Value>denorm,denorm</Value>
                 <Value>-denorm,-denorm</Value>
                 <Value>nan,nan</Value>
             </Parameter>
-            <Parameter Name="Dot2Add.Validation.Input3">
+            <Parameter Name="Validation.Input3">
                 <Value>0</Value>
                 <Value>0</Value>
                 <Value>10</Value>
@@ -4942,13 +4923,12 @@
                 <Value>0</Value>
                 <Value>10000000</Value>
                 <Value>-10000000</Value>
-                <Value>0</Value>
                 <Value>inf</Value>
                 <Value>denorm</Value>
                 <Value>-denorm</Value>
                 <Value>nan</Value>
             </Parameter>
-            <Parameter Name="Dot2Add.Validation.Expected1">
+            <Parameter Name="Validation.Expected1">
                 <Value>11</Value>
                 <Value>-11</Value>
                 <Value>21</Value>
@@ -4962,15 +4942,29 @@
                 <Value>10131008</Value>
                 <Value>-10131008</Value>
                 <Value>inf</Value>
-                <Value>inf</Value>
                 <Value>0</Value>
                 <Value>0</Value>
                 <Value>nan</Value>
             </Parameter>
-            <Parameter Name="Dot2Add.ShaderOp.Arguments">-enable-16bit-types</Parameter>
-
-            <!-- Dot4AddI8Packed Parameters -->
-            <Parameter Name="Dot4AddI8Packed.ShaderOp.Text"> struct SDot4AddI8PackedOp {
+            <Parameter Name="ShaderOp.Arguments">-enable-16bit-types</Parameter>
+        </Row>
+    </Table>
+    <Table Id="Dot4AddI8PackedOpTable">
+        <ParameterTypes>
+            <ParameterType Name="ShaderOp.Target">String</ParameterType>
+            <ParameterType Name="ShaderOp.Arguments">String</ParameterType>
+            <ParameterType Name="ShaderOp.Text">String</ParameterType>
+            <ParameterType Name="Validation.Type">String</ParameterType>
+            <ParameterType Name="Validation.Tolerance">double</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input1">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input2">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input3">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Expected1">String</ParameterType>
+        </ParameterTypes>
+        <Row Name="Dot4AddI8Packed">
+            <Parameter Name="Validation.Type">epsilon</Parameter>
+            <Parameter Name="Validation.Tolerance">0</Parameter>
+            <Parameter Name="ShaderOp.Text"> struct SDot4AddI8PackedOp {
                    dword input1;
                    dword input2;
                    int acc;
@@ -4983,8 +4977,8 @@
                     l.result = dot4add_i8packed(l.input1, l.input2, l.acc);
                     g_buf[GI] = l;
                 };</Parameter>
-            <Parameter Name="Dot4AddI8Packed.ShaderOp.Target">cs_6_4</Parameter>
-            <Parameter Name="Dot4AddI8Packed.Validation.Input1">
+            <Parameter Name="ShaderOp.Target">cs_6_4</Parameter>
+            <Parameter Name="Validation.Input1">
                 <Value>0x00000102</Value>
                 <Value>0x00000102</Value>
                 <Value>0x00000102</Value>
@@ -4996,7 +4990,7 @@
                 <Value>0x7F7F7F7F</Value>
                 <Value>0x80808080</Value>
             </Parameter>
-            <Parameter Name="Dot4AddI8Packed.Validation.Input2">
+            <Parameter Name="Validation.Input2">
                 <Value>0x00000304</Value>
                 <Value>0x00000304</Value>
                 <Value>0x00000304</Value>
@@ -5008,7 +5002,7 @@
                 <Value>0x7F7F7F7F</Value>
                 <Value>0x80808080</Value>
             </Parameter>
-            <Parameter Name="Dot4AddI8Packed.Validation.Input3">
+            <Parameter Name="Validation.Input3">
                 <Value>0</Value>
                 <Value>10</Value>
                 <Value>-5</Value>
@@ -5020,7 +5014,7 @@
                 <Value>0</Value>
                 <Value>0</Value>
             </Parameter>
-            <Parameter Name="Dot4AddI8Packed.Validation.Expected1">
+            <Parameter Name="Validation.Expected1">
                 <Value>11</Value>
                 <Value>21</Value>
                 <Value>6</Value>
@@ -5032,9 +5026,24 @@
                 <Value>64516</Value>
                 <Value>65536</Value>
             </Parameter>
-
-            <!-- Dot4AddI8Packed Parameters -->
-            <Parameter Name="Dot4AddU8Packed.ShaderOp.Text"> struct SDot4AddU8PackedOp {
+        </Row>
+    </Table>
+    <Table Id="Dot4AddU8PackedOpTable">
+        <ParameterTypes>
+            <ParameterType Name="ShaderOp.Target">String</ParameterType>
+            <ParameterType Name="ShaderOp.Arguments">String</ParameterType>
+            <ParameterType Name="ShaderOp.Text">String</ParameterType>
+            <ParameterType Name="Validation.Type">String</ParameterType>
+            <ParameterType Name="Validation.Tolerance">double</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input1">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input2">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Input3">String</ParameterType>
+            <ParameterType Array="true" Name="Validation.Expected1">String</ParameterType>
+        </ParameterTypes>
+        <Row Name="Dot4AddU8Packed">
+            <Parameter Name="Validation.Type">epsilon</Parameter>
+            <Parameter Name="Validation.Tolerance">0</Parameter>
+            <Parameter Name="ShaderOp.Text"> struct SDot4AddU8PackedOp {
                    dword input1;
                    dword input2;
                    dword acc;
@@ -5047,29 +5056,29 @@
                     l.result = dot4add_u8packed(l.input1, l.input2, l.acc);
                     g_buf[GI] = l;
                 };</Parameter>
-            <Parameter Name="Dot4AddU8Packed.ShaderOp.Target">cs_6_4</Parameter>
-            <Parameter Name="Dot4AddU8Packed.Validation.Input1">
+            <Parameter Name="ShaderOp.Target">cs_6_4</Parameter>
+            <Parameter Name="Validation.Input1">
                 <Value>0x00000102</Value>
                 <Value>0x00000102</Value>
                 <Value>0x01234567</Value>
                 <Value>0xFFFFFFFF</Value>
                 <Value>0xFFFFFFFF</Value>
             </Parameter>
-            <Parameter Name="Dot4AddU8Packed.Validation.Input2">
+            <Parameter Name="Validation.Input2">
                 <Value>0x00000304</Value>
                 <Value>0x00000304</Value>
                 <Value>0x23456789</Value>
                 <Value>0xFFFFFFFF</Value>
                 <Value>0xFFFFFFFF</Value>
             </Parameter>
-            <Parameter Name="Dot4AddU8Packed.Validation.Input3">
+            <Parameter Name="Validation.Input3">
                 <Value>0</Value>
                 <Value>10</Value>
                 <Value>10000</Value>
                 <Value>0</Value>
                 <Value>3000000000</Value>
             </Parameter>
-            <Parameter Name="Dot4AddU8Packed.Validation.Expected1">
+            <Parameter Name="Validation.Expected1">
                 <Value>11</Value>
                 <Value>21</Value>
                 <Value>33668</Value>

utils/hct/hctdb_test.py

@@ -1147,6 +1147,89 @@ def add_test_cases():
                     l.o_dot4 = dot(l.input1.xyzw, l.input2.xyzw);
                     g_buf[GI] = l;
                 };''')
+
+    # Dot2AddHalf
+    add_test_case('Dot2AddHalf', ['Dot2AddHalf'], 'epsilon', 0.008, [[
+        '1,2', '1,-2', '1,2', '-1,2', '1,2', '-1,2', '1,2', '-1,-2',
+        '65504,1', '-65504,1', '1,65504', '1,-65504', 'inf,inf',
+        'denorm,denorm', '-denorm,-denorm', 'nan,nan'
+    ], [
+        '3,4', '-3,4', '3,4', '3,-4', '3,4', '-3,4', '3,4', '-3,-4',
+        '1,65504', '1,-65504', '65504,1', '-65504,1', 'inf,inf',
+        'denorm,denorm', '-denorm,-denorm', 'nan,nan'
+    ], [
+        '0', '0', '10', '10', '-5', '-5', '-30', '-30', '0', '0',
+        '10000000', '-10000000', 'inf', 'denorm', '-denorm',
+        'nan'
+    ]], [
+        [11, -11, 21, -1, 6, 6, -19, -19, 131008, -131008, 10131008,
+         -10131008, p_inf, 0, 0, nan],
+    ], 'cs_6_4', ''' struct SDot2AddHalfOp {
+                   half2 input1;
+                   half2 input2;
+                   float acc;
+                   float result;
+                };
+                RWStructuredBuffer<SDot2AddHalfOp> g_buf : register(u0);
+                [numthreads(8,8,1)]
+                void main(uint GI : SV_GroupIndex) {
+                    SDot2AddHalfOp l = g_buf[GI];
+                    l.result = dot2add(l.input1, l.input2, l.acc);
+                    g_buf[GI] = l;
+                };''', shader_arguments='-enable-16bit-types')
+
+    # Dot4AddI8Packed
+    add_test_case('Dot4AddI8Packed', ['Dot4AddI8Packed'], 'epsilon', 0, [[
+        '0x00000102', '0x00000102', '0x00000102', '0x00000102',
+        '0XFFFFFFFF', '0x80808080', '0x80808080', '0x807F807F',
+        '0x7F7F7F7F', '0x80808080'
+    ], [
+        '0x00000304', '0x00000304', '0x00000304', '0x00000304',
+        '0xFFFFFFFF', '0x01010101', '0x7F7F7F7F', '0x807F807F',
+        '0x7F7F7F7F', '0x80808080'
+    ], [
+        '0', '10', '-5', '-30', '0', '0', '0', '0', '0', '0'
+    ]], [
+        [11, 21, 6, -19, 4, -512, -65024, 65026, 64516, 65536],
+    ], 'cs_6_4', ''' struct SDot4AddI8PackedOp {
+                   dword input1;
+                   dword input2;
+                   int acc;
+                   int result;
+                };
+                RWStructuredBuffer<SDot4AddI8PackedOp> g_buf : register(u0);
+                [numthreads(8,8,1)]
+                void main(uint GI : SV_GroupIndex) {
+                    SDot4AddI8PackedOp l = g_buf[GI];
+                    l.result = dot4add_i8packed(l.input1, l.input2, l.acc);
+                    g_buf[GI] = l;
+                };''')
+
+    # Dot4AddU8Packed
+    add_test_case('Dot4AddU8Packed', ['Dot4AddU8Packed'], 'epsilon', 0, [[
+        '0x00000102', '0x00000102', '0x01234567', '0xFFFFFFFF',
+        '0xFFFFFFFF'
+    ], [
+        '0x00000304', '0x00000304', '0x23456789', '0xFFFFFFFF',
+        '0xFFFFFFFF'
+    ], [
+        '0', '10', '10000', '0', '3000000000'
+    ]], [
+        [11, 21, 33668, 260100, 3000260100],
+    ], 'cs_6_4', ''' struct SDot4AddU8PackedOp {
+                   dword input1;
+                   dword input2;
+                   dword acc;
+                   dword result;
+                };
+                RWStructuredBuffer<SDot4AddU8PackedOp> g_buf : register(u0);
+                [numthreads(8,8,1)]
+                void main(uint GI : SV_GroupIndex) {
+                    SDot4AddU8PackedOp l = g_buf[GI];
+                    l.result = dot4add_u8packed(l.input1, l.input2, l.acc);
+                    g_buf[GI] = l;
+                };''')
+
     # Quaternary
     # Msad4 intrinsic calls both Bfi and Msad. Currently this is the only way to call bfi instruction from HLSL
     add_test_case('Bfi', ['Bfi', 'Msad'], 'epsilon', 0,
@@ -1509,6 +1592,18 @@ def generate_table_for_taef():
             ET.SubElement(root, "Table", attrib={
                 "Id": "DotOpTable"
             }), 2, 3)
+        generate_parameter_types(
+            ET.SubElement(root, "Table", attrib={
+                "Id": "Dot2AddHalfOpTable"
+            }), 3, 1)
+        generate_parameter_types(
+            ET.SubElement(root, "Table", attrib={
+                "Id": "Dot4AddI8PackedOpTable"
+            }), 3, 1)
+        generate_parameter_types(
+            ET.SubElement(root, "Table", attrib={
+                "Id": "Dot4AddU8PackedOpTable"
+            }), 3, 1)
         generate_parameter_types_msad(
             ET.SubElement(root, "Table", attrib={
                 "Id": "Msad4Table"
@@ -1671,6 +1766,16 @@ def generate_table_for_taef():
                     print(cur_inst.dxil_class)
             elif cur_inst.category == "Dot":
                 generate_row(root.find("./Table[@Id='DotOpTable']"), case)
+            elif cur_inst.category == "Dot product with accumulate":
+                if cur_inst.name == "Dot2AddHalf":
+                    generate_row(root.find("./Table[@Id='Dot2AddHalfOpTable']"), case)
+                elif cur_inst.name == "Dot4AddI8Packed":
+                    generate_row(root.find("./Table[@Id='Dot4AddI8PackedOpTable']"), case)
+                elif cur_inst.name == "Dot4AddU8Packed":
+                    generate_row(root.find("./Table[@Id='Dot4AddU8PackedOpTable']"), case)
+                else:
+                    print("unknown op: " + cur_inst.name)
+                    print(cur_inst.dxil_class)
             elif cur_inst.dxil_class in ["WaveActiveOp", "WaveAllOp","WaveActiveAllEqual","WaveAnyTrue","WaveAllTrue"]:
                 if case.test_name.startswith("WaveActiveU"):
                     generate_row_wave(