adding more test

Author: joaosaffran

tools/clang/unittests/HLSLExec/LongVectorOps.def

@@ -61,8 +61,13 @@ OP(Bitwise, FirstBitLow, 1, "firstbitlow", "", "", "LongVectorOp", Bitwise, Defa
 
 OP_DEFAULT_DEFINES(Unary, Initialize, 1, "TestInitialize", "",
                    " -DFUNC_INITIALIZE=1")
-OP_DEFAULT_DEFINES(Unary, ArrayOperator_SingleAccess, 1, "TestArrayOperatorSingleAccess", "",
+
+OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_SingleAccess, 1, "TestArrayOperatorSingleAccess", "",
                    " -DFUNC_ARRAY_OPERATOR_SINGLE_ACCESS=1")
+OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_Loop, 2, "TestArrayOperatorLoop", "",
+                   " -DFUNC_ARRAY_OPERATOR=1 -DLOOP_ATTRB=loop")
+OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_Unroll, 2, "TestArrayOperatorUnroll", "",
+                   " -DFUNC_ARRAY_OPERATOR=1 -DLOOP_ATTRB=unroll")
 
 
 #define OP_CAST_DEFAULT(GROUP, SYMBOL)                                         \

tools/clang/unittests/HLSLExec/LongVectors.cpp

@@ -785,6 +785,42 @@ struct ExpectedBuilder<OpType::ArrayOperator_SingleAccess, T> {
   }
 };
 
+template <typename T>
+static std::vector<T> BuildLoop2(const InputSets<T> &Inputs) {
+  DXASSERT_NOMSG(Inputs.size() == 2);
+  const size_t VectorSize = Inputs[0].size();
+  std::vector<T> Expected;
+  Expected.resize(VectorSize * 2);
+
+  for (size_t i = 0; i < VectorSize; i++)
+    Expected[i] = Inputs[0][i] + Inputs[1][i];
+
+  for (size_t i = 0; i < VectorSize; i++)
+    Expected[i + VectorSize] = Expected[i];
+
+  return Expected;
+}
+
+template <typename T>
+struct Op<OpType::ArrayOperator_Loop, T, 2> : DefaultValidation<T> {};
+
+template <typename T> struct ExpectedBuilder<OpType::ArrayOperator_Loop, T> {
+  static std::vector<T> buildExpected(Op<OpType::ArrayOperator_Loop, T, 2>,
+                                      const InputSets<T> &Inputs) {
+    return BuildLoop2(Inputs);
+  }
+};
+
+template <typename T>
+struct Op<OpType::ArrayOperator_Unroll, T, 2> : DefaultValidation<T> {};
+
+template <typename T> struct ExpectedBuilder<OpType::ArrayOperator_Unroll, T> {
+  static std::vector<T> buildExpected(Op<OpType::ArrayOperator_Unroll, T, 2>,
+                                      const InputSets<T> &Inputs) {
+    return BuildLoop2(Inputs);
+  }
+};
+
 //
 // Cast
 //
@@ -1604,24 +1640,44 @@ class DxilConf_SM69_Vectorized {
 
   HLK_TEST(Initialize, HLSLBool_t);
   HLK_TEST(ArrayOperator_SingleAccess, HLSLBool_t);
+  HLK_TEST(ArrayOperator_Unroll, HLSLBool_t);
+  HLK_TEST(ArrayOperator_Loop, HLSLBool_t);
   HLK_TEST(Initialize, int16_t);
   HLK_TEST(ArrayOperator_SingleAccess, int16_t);
+  HLK_TEST(ArrayOperator_Unroll, int16_t);
+  HLK_TEST(ArrayOperator_Loop, int16_t);
   HLK_TEST(Initialize, int32_t);
   HLK_TEST(ArrayOperator_SingleAccess, int32_t);
+  HLK_TEST(ArrayOperator_Unroll, int32_t);
+  HLK_TEST(ArrayOperator_Loop, int32_t);
   HLK_TEST(Initialize, int64_t);
   HLK_TEST(ArrayOperator_SingleAccess, int64_t);
+  HLK_TEST(ArrayOperator_Unroll, int64_t);
+  HLK_TEST(ArrayOperator_Loop, int64_t);
   HLK_TEST(Initialize, uint16_t);
   HLK_TEST(ArrayOperator_SingleAccess, uint16_t);
+  HLK_TEST(ArrayOperator_Unroll, uint16_t);
+  HLK_TEST(ArrayOperator_Loop, uint16_t);
   HLK_TEST(Initialize, uint32_t);
   HLK_TEST(ArrayOperator_SingleAccess, uint32_t);
+  HLK_TEST(ArrayOperator_Unroll, uint32_t);
+  HLK_TEST(ArrayOperator_Loop, uint32_t);
   HLK_TEST(Initialize, uint64_t);
   HLK_TEST(ArrayOperator_SingleAccess, uint64_t);
+  HLK_TEST(ArrayOperator_Unroll, uint64_t);
+  HLK_TEST(ArrayOperator_Loop, uint64_t);
   HLK_TEST(Initialize, HLSLHalf_t);
   HLK_TEST(ArrayOperator_SingleAccess, HLSLHalf_t);
+  HLK_TEST(ArrayOperator_Unroll, HLSLHalf_t);
+  HLK_TEST(ArrayOperator_Loop, HLSLHalf_t);
   HLK_TEST(Initialize, float);
   HLK_TEST(ArrayOperator_SingleAccess, float);
+  HLK_TEST(ArrayOperator_Unroll, float);
+  HLK_TEST(ArrayOperator_Loop, float);
   HLK_TEST(Initialize, double);
   HLK_TEST(ArrayOperator_SingleAccess, double);
+  HLK_TEST(ArrayOperator_Unroll, double);
+  HLK_TEST(ArrayOperator_Loop, double);
 
   HLK_TEST(ShuffleVector, HLSLBool_t);
   HLK_TEST(ShuffleVector, int16_t);

tools/clang/unittests/HLSLExec/ShaderOpArith.xml

@@ -4134,6 +4134,14 @@ void MSMain(uint GID : SV_GroupIndex,
             NUM> >(0);
             OutputVector[0] = Input1[OutNum - 1];
             OutputVector[OutNum - 1] = OutputVector[0];
+          #elif FUNC_ARRAY_OPERATOR
+            vector<OUT_TYPE, OutNum> OutputVector;
+            
+            [LOOP_ATTRB] for(uint i = 0; i < OutNum; i++)
+              OutputVector[i] = Input1[i] + Input2[i];
+            
+            [LOOP_ATTRB] for(uint i = 0; i < OutNum; i++) 
+              g_OutputVector.Store<OUT_TYPE>(sizeof(OUT_TYPE) * (OutNum + i), OutputVector[i]);
           #elif IS_UNARY_OP
             vector<OUT_TYPE, OutNum> OutputVector = FUNC(Input1);
           #elif IS_BINARY_OP