[mlir] NFC - Move Vector structure from RunnerUtils.h to CRunnerUtils.h

[nicolasvasilache]

Summary

The Vector struct does not require a C++ runtime.

[ftynse]

LGTM if you comply with clang-format. (Literally copy-pasting the code should be fine, don't know why you decided to reformat it).

[nicolasvasilache]

I did encounter a few cases where my clang-format does not agree with what phab says.
I rebuilt clang at HEAD today and I have:

.../llvm-project$ git-clang-format --binary=./build/bin/clang-format --style=LLVM HEAD^
clang-format did not modify any files

I can manually "fix" the format to make phab happy like I did in the past but I doubt phab is right.

[ftynse]

I rebuilt clang at HEAD today and I have:

I think we are running some stable version of clang-format. @mehdi_amini for more context.

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

 
 #include <cstdint>
 
 template <int N> void dropFront(int64_t arr[N], int64_t *res) {
   for (unsigned i = 1; i < N; ++i)
     *(res + i - 1) = arr[i];
 }
 
+//===----------------------------------------------------------------------===//
+// Codegen-compatible structures for Vector type.
+//===----------------------------------------------------------------------===//
+template <typename T, int Dim, int... Dims>
+struct Vector {
+  Vector<T, Dims...> vector[Dim];
+};
+
+template <typename T, int Dim>
+struct Vector<T, Dim> {
+  T vector[Dim];
+};
+
+template <int D1, typename T>
+using Vector1D = Vector<T, D1>;
+template <int D1, int D2, typename T>
+using Vector2D = Vector<T, D1, D2>;
+template <int D1, int D2, int D3, typename T>
+using Vector3D = Vector<T, D1, D2, D3>;
+template <int D1, int D2, int D3, int D4, typename T>
+using Vector4D = Vector<T, D1, D2, D3, D4>;
+
+//===----------------------------------------------------------------------===//
+// Codegen-compatible structures for StridedMemRef type.
+//===----------------------------------------------------------------------===//
 /// StridedMemRef descriptor type with static rank.
 template <typename T, int N> struct StridedMemRefType {
   T *basePtr;
   T *data;
   int64_t offset;
   int64_t sizes[N];
   int64_t strides[N];
   // This operator[] is extremely slow and only for sugaring purposes.

 
 /// StridedMemRef descriptor type specialized for rank 0.
 template <typename T> struct StridedMemRefType<T, 0> {
   T *basePtr;
   T *data;
   int64_t offset;
 };
 
+//===----------------------------------------------------------------------===//
+// Codegen-compatible structure for UnrankedMemRef type.
+//===----------------------------------------------------------------------===//
 // Unranked MemRef
 template <typename T> struct UnrankedMemRefType {
   int64_t rank;
   void *descriptor;
 };
 
-// Small runtime support "lib" for vector.print lowering.
+//===----------------------------------------------------------------------===//
+// Small runtime support "lib" for vector.print lowering during codegen.
+//===----------------------------------------------------------------------===//
 extern "C" MLIR_CRUNNERUTILS_EXPORT void print_f32(float f);
 extern "C" MLIR_CRUNNERUTILS_EXPORT void print_f64(double d);
 extern "C" MLIR_CRUNNERUTILS_EXPORT void print_open();
 extern "C" MLIR_CRUNNERUTILS_EXPORT void print_close();
 extern "C" MLIR_CRUNNERUTILS_EXPORT void print_comma();
 extern "C" MLIR_CRUNNERUTILS_EXPORT void print_newline();
 
 #endif // EXECUTIONENGINE_CRUNNERUTILS_H_

mlir/include/mlir/ExecutionEngine/RunnerUtils.h

 }
 
 template <typename T, typename StreamType>
 void printUnrankedMemRefMetaData(StreamType &os, UnrankedMemRefType<T> &V) {
   os << "Unranked Memref rank = " << V.rank << " "
      << "descriptor@ = " << reinterpret_cast<void *>(V.descriptor) << "\n";
 }
 
-template <typename T, int Dim, int... Dims> struct Vector {
-  Vector<T, Dims...> vector[Dim];
-};
-template <typename T, int Dim> struct Vector<T, Dim> { T vector[Dim]; };
-
-template <int D1, typename T> using Vector1D = Vector<T, D1>;
-template <int D1, int D2, typename T> using Vector2D = Vector<T, D1, D2>;
-template <int D1, int D2, int D3, typename T>
-using Vector3D = Vector<T, D1, D2, D3>;
-template <int D1, int D2, int D3, int D4, typename T>
-using Vector4D = Vector<T, D1, D2, D3, D4>;
-
 ////////////////////////////////////////////////////////////////////////////////
 // Templated instantiation follows.
 ////////////////////////////////////////////////////////////////////////////////
 namespace impl {
 template <typename T, int M, int... Dims>
 std::ostream &operator<<(std::ostream &os, const Vector<T, M, Dims...> &v);
 
 template <int... Dims> struct StaticSizeMult {