[mlir][sparse] Adding x-macros for OverheadType

[aartbik]

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

282

Does it perhaps make sense to use some suffix for index instead
(just asking atm, since this will be a large CL fixing quite some checks too)

286

I would remove the stack overflow links, the empty concat is quite obvious (I think)

[wrengr]

Replacing stackoverflow links with direct references to the standard

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

282

I'm cool with either approach, though it would make the API cleaner to have a suffix. If we go that route, I think it'd be better to make that change as a separate differential just cuz it'll have to touch a whole bunch of other files (whereas this differential is pretty self-contained).

286

Removed. I've added the relevant commentary (namely that it's official spec for C++11 and C99, unlike C++03 where it was undefined behavior (albeit generally supported in the now-official way)). Though, of course, that comment will no longer be necessary if/when we add a suffix for the index_type case :)

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

#define FOREVERY_SIMPLEX_V(DO)                                                 \
   DO(I16, int16_t)                                                             \
   DO(I8, int8_t)
 
 #define FOREVERY_V(DO)                                                         \
   FOREVERY_SIMPLEX_V(DO)                                                       \
   DO(C64, complex64)                                                           \
   DO(C32, complex32)
 
+// This x-macro calls its argument on every overhead type which has
+// fixed-width.  It excludes `index_type` because that type is often
+// handled specially (e.g., by translating it into the architecture-dependent
+// equivalent fixed-width overhead type).
+#define FOREVERY_FIXED_O(DO)                                                   \
+  DO(64, uint64_t)                                                             \
+  DO(32, uint32_t)                                                             \
+  DO(16, uint16_t)                                                             \
+  DO(8, uint8_t)
+
+// This x-macro calls its argument on every overhead type, including
+// `index_type`.  Our naming convention uses an empty suffix for
+// `index_type`, so the missing first argument when we call `DO`
+// gets resolved to the empty token which can then be concatenated
+// as intended.  (This behavior is standard per C99 6.10.3/4 and
+// C++11 N3290 16.3/4; whereas in C++03 16.3/10 it was undefined behavior.)
+#define FOREVERY_O(DO)                                                         \
+  FOREVERY_FIXED_O(DO)                                                         \
+  DO(, index_type)
+
 // Forward.
 template <typename V>
 class SparseTensorEnumeratorBase;
 
 // Helper macro for generating error messages when some
 // `SparseTensorStorage<P,I,V>` is cast to `SparseTensorStorageBase`
 // and then the wrong "partial method specialization" is called.
 #define FATAL_PIV(NAME) FATAL("<P,I,V> type mismatch for: " #NAME);
#define DECL_NEWENUMERATOR(VNAME, V)                                           \
   virtual void newEnumerator(SparseTensorEnumeratorBase<V> **, uint64_t,       \
                              const uint64_t *) const {                         \
     FATAL_PIV("newEnumerator" #VNAME);                                         \
   }
   FOREVERY_V(DECL_NEWENUMERATOR)
 #undef DECL_NEWENUMERATOR
 
   /// Overhead storage.
-  virtual void getPointers(std::vector<uint64_t> **, uint64_t) {
-    FATAL_PIV("p64");
-  }
-  virtual void getPointers(std::vector<uint32_t> **, uint64_t) {
-    FATAL_PIV("p32");
-  }
-  virtual void getPointers(std::vector<uint16_t> **, uint64_t) {
-    FATAL_PIV("p16");
-  }
-  virtual void getPointers(std::vector<uint8_t> **, uint64_t) {
-    FATAL_PIV("p8");
-  }
-  virtual void getIndices(std::vector<uint64_t> **, uint64_t) {
-    FATAL_PIV("i64");
-  }
-  virtual void getIndices(std::vector<uint32_t> **, uint64_t) {
-    FATAL_PIV("i32");
-  }
-  virtual void getIndices(std::vector<uint16_t> **, uint64_t) {
-    FATAL_PIV("i16");
-  }
-  virtual void getIndices(std::vector<uint8_t> **, uint64_t) {
-    FATAL_PIV("i8");
+#define DECL_GETPOINTERS(PNAME, P)                                             \
+  virtual void getPointers(std::vector<P> **, uint64_t) {                      \
+    FATAL_PIV("getPointers" #PNAME);                                           \
+  }
+  FOREVERY_FIXED_O(DECL_GETPOINTERS)
+#undef DECL_GETPOINTERS
+#define DECL_GETINDICES(INAME, I)                                              \
+  virtual void getIndices(std::vector<I> **, uint64_t) {                       \
+    FATAL_PIV("getIndices" #INAME);                                            \
   }
+  FOREVERY_FIXED_O(DECL_GETINDICES)
+#undef DECL_GETINDICES
 
   /// Primary storage.
 #define DECL_GETVALUES(VNAME, V)                                               \
   virtual void getValues(std::vector<V> **) { FATAL_PIV("getValues" #VNAME); }
   FOREVERY_V(DECL_GETVALUES)
 #undef DECL_GETVALUES
 
   /// Element-wise insertion in lexicographic index order.
void _mlir_ciface_##NAME(StridedMemRefType<TYPE, 1> *ref, void *tensor,      \
     std::vector<TYPE> *v;                                                      \
     static_cast<SparseTensorStorageBase *>(tensor)->LIB(&v, d);                \
     ref->basePtr = ref->data = v->data();                                      \
     ref->offset = 0;                                                           \
     ref->sizes[0] = v->size();                                                 \
     ref->strides[0] = 1;                                                       \
   }
 /// Methods that provide direct access to pointers.
-IMPL_GETOVERHEAD(sparsePointers, index_type, getPointers)
-IMPL_GETOVERHEAD(sparsePointers64, uint64_t, getPointers)
-IMPL_GETOVERHEAD(sparsePointers32, uint32_t, getPointers)
-IMPL_GETOVERHEAD(sparsePointers16, uint16_t, getPointers)
-IMPL_GETOVERHEAD(sparsePointers8, uint8_t, getPointers)
+#define IMPL_SPARSEPOINTERS(PNAME, P)                                          \
+  IMPL_GETOVERHEAD(sparsePointers##PNAME, P, getPointers)
+FOREVERY_O(IMPL_SPARSEPOINTERS)
+#undef IMPL_SPARSEPOINTERS
 
 /// Methods that provide direct access to indices.
-IMPL_GETOVERHEAD(sparseIndices, index_type, getIndices)
-IMPL_GETOVERHEAD(sparseIndices64, uint64_t, getIndices)
-IMPL_GETOVERHEAD(sparseIndices32, uint32_t, getIndices)
-IMPL_GETOVERHEAD(sparseIndices16, uint16_t, getIndices)
-IMPL_GETOVERHEAD(sparseIndices8, uint8_t, getIndices)
+#define IMPL_SPARSEINDICES(INAME, I)                                           \
+  IMPL_GETOVERHEAD(sparseIndices##INAME, I, getIndices)
+FOREVERY_O(IMPL_SPARSEINDICES)
+#undef IMPL_SPARSEINDICES
 #undef IMPL_GETOVERHEAD
 
 /// Helper to add value to coordinate scheme, one per value type.
 #define IMPL_ADDELT(VNAME, V)                                                  \
   void *_mlir_ciface_addElt##VNAME(void *coo, V value,                         \
                                    StridedMemRefType<index_type, 1> *iref,     \
                                    StridedMemRefType<index_type, 1> *pref) {   \
     assert(coo &&iref &&pref);                                                 \