Implement Split/MakeDouble tests (microsoft#7675)

Adds two additional 'AsType' exec tests. One for AsUint and one for
AsDouble. Which map to the Split and MakeDouble.
Also added some new code comments to help clarify a few things. 
Also cleans up some dead code left over from remove clamp in a previous
PR.

Resolves microsoft#7667

Author: alsepkow

tools/clang/unittests/HLSLExec/LongVectorOpTable.xml

@@ -314,6 +314,10 @@
           <Parameter Name="OpTypeEnum">BinaryOpType_Max</Parameter>
           <Parameter Name="DataType">uint32</Parameter>
         </Row>
+        <Row Name="AsDouble_uint32">
+          <Parameter Name="OpTypeEnum">BinaryOpType_AsDouble</Parameter>
+          <Parameter Name="DataType">uint32</Parameter>
+        </Row>
         <!-- LongVectorBinaryOpTypeTable DataType: uint64 -->
         <Row Name="ScalarAdd_uint64">
           <Parameter Name="OpTypeEnum">BinaryOpType_ScalarAdd</Parameter>
@@ -655,6 +659,13 @@
         <Parameter Name="OpTypeEnum">UnaryOpType_Initialize</Parameter>
         <Parameter Name="DataType">float64</Parameter>
       </Row>
+      <Row Name="AsUint_SplitDouble_float64">
+        <Parameter Name="OpTypeEnum">UnaryOpType_AsUint_SplitDouble</Parameter>
+        <Parameter Name="DataType">float64</Parameter>
+        <!-- Use a special InputValueSetName1 so we verify with values that
+        produce non-zero outputs for HighBits and LowBits -->
+        <Parameter Name="InputValueSetName1">SplitDoubleInputValueSet</Parameter>
+      </Row>
     </Table>
     <Table Id="TrigonometricOpTable">
       <ParameterTypes>

tools/clang/unittests/HLSLExec/LongVectorTestData.h

@@ -292,7 +292,10 @@ template <> struct LongVectorTestData<double> {
         -0.883}},
       {L"TrigonometricInputValueSet_RangeOne",
        {0.331, 0.277, -0.957, 0.677, -0.025, 0.495, 0.855, -0.673, -0.678,
-        -0.905}}};
+        -0.905}},
+      {L"SplitDoubleInputValueSet",
+       {0.0, -1.0, 1.0, -1.0, 12345678.87654321, -1.0, 1.0, -1.0, 1.0, -1.0}},
+  };
 };
 
 #endif // LONGVECTORTESTDATA_H

tools/clang/unittests/HLSLExec/LongVectors.cpp

@@ -337,14 +337,7 @@ void LongVector::OpTest::testBaseMethod(
             L"RunShaderOpTest CallBack. Unexpected Resource Name: %S", Name);
       });
 
-  // Map the data from GPU to CPU memory so we can verify our expectations.
-  MappedData ShaderOutData;
-  TestResult->Test->GetReadBackData("OutputVector", &ShaderOutData);
-
-  // The TestConfig object help handles more complicated verification cases. We
-  // pass in the MappedData instead of the typed data because the TestConfig may
-  // need to resolve the output type for test cases where the return type of the
-  // intrinsic being tested does not match the input type, such as the AsType*
-  // intrinsics (AsInt, AsInt16, AsFloat, ... etc).
-  VERIFY_SUCCEEDED(TestConfig.verifyOutput(ShaderOutData));
+  // The TestConfig object handles the logic for extracting the shader output
+  // based on the op type.
+  VERIFY_SUCCEEDED(TestConfig.verifyOutput(TestResult));
 }

tools/clang/unittests/HLSLExec/LongVectors.h

@@ -146,6 +146,7 @@ enum BinaryOpType {
   BinaryOpType_Max,
   BinaryOpType_ScalarMin,
   BinaryOpType_ScalarMax,
+  BinaryOpType_AsDouble,
   BinaryOpType_EnumValueCount
 };
 
@@ -164,6 +165,7 @@ static const LongVectorOpTypeStringToEnumValue binaryOpTypeStringToEnumMap[] = {
     {L"BinaryOpType_Max", BinaryOpType_Max},
     {L"BinaryOpType_ScalarMin", BinaryOpType_ScalarMin},
     {L"BinaryOpType_ScalarMax", BinaryOpType_ScalarMax},
+    {L"BinaryOpType_AsDouble", BinaryOpType_AsDouble},
 };
 
 static_assert(_countof(binaryOpTypeStringToEnumMap) ==
@@ -180,6 +182,7 @@ enum UnaryOpType {
   UnaryOpType_AsInt,
   UnaryOpType_AsInt16,
   UnaryOpType_AsUint,
+  UnaryOpType_AsUint_SplitDouble,
   UnaryOpType_AsUint16,
   UnaryOpType_EnumValueCount
 };
@@ -191,6 +194,7 @@ static const LongVectorOpTypeStringToEnumValue unaryOpTypeStringToEnumMap[] = {
     {L"UnaryOpType_AsInt", UnaryOpType_AsInt},
     {L"UnaryOpType_AsInt16", UnaryOpType_AsInt16},
     {L"UnaryOpType_AsUint", UnaryOpType_AsUint},
+    {L"UnaryOpType_AsUint_SplitDouble", UnaryOpType_AsUint_SplitDouble},
     {L"UnaryOpType_AsUint16", UnaryOpType_AsUint16},
 };
 
@@ -327,6 +331,38 @@ unsigned int asUint(const int &A) {
   return LongVector::bit_cast<unsigned int>(A);
 }
 
+template <typename DataTypeInT>
+void splitDouble([[maybe_unused]] const DataTypeInT &A,
+                 [[maybe_unused]] uint32_t &LowBits,
+                 [[maybe_unused]] uint32_t &HighBits) {
+  LOG_ERROR_FMT_THROW(L"Programmer Error: splitDouble only accepts a double as "
+                      L"input. Have DataTypeInT: %S",
+                      typeid(DataTypeInT).name());
+}
+
+void splitDouble(const double &A, uint32_t &LowBits, uint32_t &HighBits) {
+  uint64_t Bits = 0;
+  std::memcpy(&Bits, &A, sizeof(Bits));
+  LowBits = static_cast<uint32_t>(Bits & 0xFFFFFFFF);
+  HighBits = static_cast<uint32_t>(Bits >> 32);
+}
+
+template <typename DataTypeInT>
+double asDouble([[maybe_unused]] const DataTypeInT &LowBits,
+                [[maybe_unused]] const DataTypeInT &HighBits) {
+  LOG_ERROR_FMT_THROW(L"Programmer Error: asDouble only accepts two uint32_t "
+                      L"inputs. Have DataTypeInT : %S",
+                      typeid(DataTypeInT).name());
+  return 0.0;
+}
+
+double asDouble(const uint32_t &LowBits, const uint32_t &HighBits) {
+  uint64_t Bits = (static_cast<uint64_t>(HighBits) << 32) | LowBits;
+  double Result;
+  std::memcpy(&Result, &Bits, sizeof(Result));
+  return Result;
+}
+
 template <typename LongVectorOpTypeT> struct TestConfigTraits {
   TestConfigTraits(LongVectorOpTypeT OpType) : OpType(OpType) {}
   // LongVectorOpTypeT* Enum values. We don't use a UINT because
@@ -393,9 +429,6 @@ template <typename DataTypeT, typename LongVectorOpTypeT> class TestConfig {
 
   bool isAsTypeOp() const { return isAsTypeOp(OpTypeTraits.OpType); }
 
-  bool hasFunctionDefinition() const;
-  std::string getOPERAND2String() const;
-
   // Helpers to get the hlsl type as a string for a given C++ type.
   std::string getHLSLInputTypeString() const;
   std::string getHLSLOutputTypeString() const;
@@ -409,6 +442,9 @@ template <typename DataTypeT, typename LongVectorOpTypeT> class TestConfig {
   DataTypeT computeExpectedValue(const DataTypeT &A) const;
   void
   computeExpectedValuesForAsTypeOp(const std::vector<DataTypeT> &InputVector1);
+  void
+  computeExpectedValuesForAsTypeOp(const std::vector<DataTypeT> &InputVector1,
+                                   const std::vector<DataTypeT> &InputVector2);
 
   void setInputArgsArrayName(const std::wstring &InputArgsArrayName) {
     this->InputArgsArrayName = InputArgsArrayName;
@@ -451,28 +487,29 @@ template <typename DataTypeT, typename LongVectorOpTypeT> class TestConfig {
 
   LongVector::VariantVector &getExpectedVector() { return ExpectedVector; }
 
-  bool verifyOutput(MappedData &ShaderOutData);
+  bool verifyOutput(const std::shared_ptr<st::ShaderOpTestResult> &TestResult);
 
 private:
   bool isAsTypeOp(LongVector::UnaryOpType OpType) const;
-  bool isAsTypeOp(LongVector::BinaryOpType) const { return false; }
+  bool isAsTypeOp(LongVector::BinaryOpType) const;
   bool isAsTypeOp(LongVector::TrigonometricOpType) const { return false; }
 
-  std::string HLSLOutputTypeString(LongVector::UnaryOpType OpType) const;
-
-  bool resolveOutputTypeAndVerifyOutput(MappedData &ShaderOutData);
+  bool resolveOutputTypeAndVerifyOutput(
+      const std::shared_ptr<st::ShaderOpTestResult> &TestResult);
 
   // Templated version to be used when the output data type does not match the
   // input data type.
   template <typename OutputDataTypeT>
-  bool verifyOutput(MappedData &ShaderOutData);
+  bool verifyOutput(const std::shared_ptr<st::ShaderOpTestResult> &TestResult);
 
   std::vector<DataTypeT> getInputValueSet(size_t ValueSetIndex) const;
 
   // To be used for the value of -DOPERATOR
   std::string OperatorString;
   // To be used for the value of -DFUNC
   std::string IntrinsicString;
+  // Used to add special -D defines to the compiler options.
+  std::string SpecialDefines = "";
   LongVector::BasicOpType BasicOpType = LongVector::BasicOpType_EnumValueCount;
   float Tolerance = 0.0;
   LongVector::ValidationType ValidationType =