[mlir] Use std::size instead of llvm::array_lengthof

[jloser]

Summary

LLVM contains a helpful function for getting the size of a C-style
array: llvm::array_lengthof. This is useful prior to C++17, but not as
helpful for C++17 or later: std::size already has support for C-style
arrays.

Change call sites to use std::size instead.

[jloser]

Remove #include <iterator> from SPIRVBase.td

[rriddle]

Nice!

[antiagainst]

Cool! Just one nit about formatting.

mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp

635

Format needs to be adjusted here?

[jloser]

clang-format and rebase

[jloser]

mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp

635

Yep, I just ran git clang-format to fix this up — thanks!

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

class Extension<list<I32EnumAttrCase> extensions> : Availability {
   // Pack all extensions as a static array and get its reference.
   let instancePreparation = !if(!empty(extensions), "",
     "static const ::mlir::spirv::Extension exts[] = {" #
     !interleave(!foreach(ext, extensions,
                          "::mlir::spirv::Extension::" # ext.symbol), ", ") #
     "}; " #
     // The following manual ArrayRef constructor call is to satisfy GCC 5.
     "ArrayRef<::mlir::spirv::Extension> " #
-      "ref(exts, ::llvm::array_lengthof(exts));");
+      "ref(exts, std::size(exts));");
   let instance = "ref";
 }
 
 class Capability<list<I32EnumAttrCase> capabilities> : Availability {
   let cppNamespace = "::mlir::spirv";
   let interfaceName = "QueryCapabilityInterface";
   let interfaceDescription = [{
     Querying interface for required SPIR-V capabilities.
class Capability<list<I32EnumAttrCase> capabilities> : Availability {
   // Pack all capabilities as a static array and get its reference.
   let instancePreparation = !if(!empty(capabilities), "",
     "static const ::mlir::spirv::Capability caps[] = {" #
     !interleave(!foreach(cap, capabilities,
                          "::mlir::spirv::Capability::" # cap.symbol), ", ") #
     "}; " #
     // The following manual ArrayRef constructor call is to satisfy GCC 5.
     "ArrayRef<::mlir::spirv::Capability> " #
-      "ref(caps, ::llvm::array_lengthof(caps));");
+      "ref(caps, std::size(caps));");
   let instance = "ref";
 }
 
 class SPIRVOpInterface<string name> : OpInterface<name> {
   let cppNamespace = "::mlir::spirv";
 }
 // TODO: the following interfaces definitions are duplicating with the above.
 // Remove them once we are able to support dialect-specific contents in ODS.

mlir/lib/Dialect/SPIRV/IR/SPIRVEnums.cpp

 
 #include "mlir/IR/BuiltinTypes.h"
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 
+#include <iterator>
+
 using namespace mlir;
 
 // Pull in all enum utility function definitions
 #include "mlir/Dialect/SPIRV/IR/SPIRVEnums.cpp.inc"
 
 // Pull in all enum type availability query function definitions
 #include "mlir/Dialect/SPIRV/IR/SPIRVEnumAvailability.cpp.inc"
 
Extension::SPV_KHR_8bit_storage, Extension::SPV_EXT_descriptor_indexing,     \
       Extension::SPV_KHR_vulkan_memory_model
 
   switch (version) {
   default:
     return {};
   case Version::V_1_3: {
     // The following manual ArrayRef constructor call is to satisfy GCC 5.
     static const Extension exts[] = {V_1_3_IMPLIED_EXTS};
-    return ArrayRef<spirv::Extension>(exts, llvm::array_lengthof(exts));
+    return ArrayRef<spirv::Extension>(exts, std::size(exts));
   }
   case Version::V_1_4: {
     static const Extension exts[] = {V_1_3_IMPLIED_EXTS, V_1_4_IMPLIED_EXTS};
-    return ArrayRef<spirv::Extension>(exts, llvm::array_lengthof(exts));
+    return ArrayRef<spirv::Extension>(exts, std::size(exts));
   }
   case Version::V_1_5: {
     static const Extension exts[] = {V_1_3_IMPLIED_EXTS, V_1_4_IMPLIED_EXTS,
                                      V_1_5_IMPLIED_EXTS};
-    return ArrayRef<spirv::Extension>(exts, llvm::array_lengthof(exts));
+    return ArrayRef<spirv::Extension>(exts, std::size(exts));
   }
   }
 
 #undef V_1_5_IMPLIED_EXTS
 #undef V_1_4_IMPLIED_EXTS
 #undef V_1_3_IMPLIED_EXTS
 }
 

mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp

 
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+#include <iterator>
+
 using namespace mlir;
 using namespace mlir::spirv;
 
 //===----------------------------------------------------------------------===//
 // ArrayType
 //===----------------------------------------------------------------------===//
 
 struct spirv::detail::ArrayTypeStorage : public TypeStorage {
void CompositeType::getCapabilities(
   TypeSwitch<Type>(*this)
       .Case<ArrayType, CooperativeMatrixNVType, JointMatrixINTELType,
             MatrixType, RuntimeArrayType, StructType>(
           [&](auto type) { type.getCapabilities(capabilities, storage); })
       .Case<VectorType>([&](VectorType type) {
         auto vecSize = getNumElements();
         if (vecSize == 8 || vecSize == 16) {
           static const Capability caps[] = {Capability::Vector16};
-          ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));
+          ArrayRef<Capability> ref(caps, std::size(caps));
           capabilities.push_back(ref);
         }
         return type.getElementType().cast<ScalarType>().getCapabilities(
             capabilities, storage);
       })
       .Default([](Type) { llvm_unreachable("invalid composite type"); });
 }
 
unsigned CooperativeMatrixNVType::getColumns() const {
   return getImpl()->columns;
 }
 
 void CooperativeMatrixNVType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
     Optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
   static const Extension exts[] = {Extension::SPV_NV_cooperative_matrix};
-  ArrayRef<Extension> ref(exts, llvm::array_lengthof(exts));
+  ArrayRef<Extension> ref(exts, std::size(exts));
   extensions.push_back(ref);
 }
 
 void CooperativeMatrixNVType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     Optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
   static const Capability caps[] = {Capability::CooperativeMatrixNV};
-  ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));
+  ArrayRef<Capability> ref(caps, std::size(caps));
   capabilities.push_back(ref);
 }
 
 //===----------------------------------------------------------------------===//
 // JointMatrixType
 //===----------------------------------------------------------------------===//
 
 struct spirv::detail::JointMatrixTypeStorage : public TypeStorage {
MatrixLayout JointMatrixINTELType::getMatrixLayout() const {
   return getImpl()->matrixLayout;
 }
 
 void JointMatrixINTELType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
     Optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
   static const Extension exts[] = {Extension::SPV_INTEL_joint_matrix};
-  ArrayRef<Extension> ref(exts, llvm::array_lengthof(exts));
+  ArrayRef<Extension> ref(exts, std::size(exts));
   extensions.push_back(ref);
 }
 
 void JointMatrixINTELType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     Optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
   static const Capability caps[] = {Capability::JointMatrixINTEL};
-  ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));
+  ArrayRef<Capability> ref(caps, std::size(caps));
   capabilities.push_back(ref);
 }
 
 //===----------------------------------------------------------------------===//
 // ImageType
 //===----------------------------------------------------------------------===//
 
 template <typename T>
void RuntimeArrayType::getExtensions(
   getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
 }
 
 void RuntimeArrayType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     Optional<StorageClass> storage) {
   {
     static const Capability caps[] = {Capability::Shader};
-    ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));
+    ArrayRef<Capability> ref(caps, std::size(caps));
     capabilities.push_back(ref);
   }
   getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
 }
 
 //===----------------------------------------------------------------------===//
 // ScalarType
 //===----------------------------------------------------------------------===//
if (!storage)
     return;
 
   switch (*storage) {
   case StorageClass::PushConstant:
   case StorageClass::StorageBuffer:
   case StorageClass::Uniform:
     if (getIntOrFloatBitWidth() == 8) {
       static const Extension exts[] = {Extension::SPV_KHR_8bit_storage};
-      ArrayRef<Extension> ref(exts, llvm::array_lengthof(exts));
+      ArrayRef<Extension> ref(exts, std::size(exts));
       extensions.push_back(ref);
     }
     [[fallthrough]];
   case StorageClass::Input:
   case StorageClass::Output:
     if (getIntOrFloatBitWidth() == 16) {
       static const Extension exts[] = {Extension::SPV_KHR_16bit_storage};
-      ArrayRef<Extension> ref(exts, llvm::array_lengthof(exts));
+      ArrayRef<Extension> ref(exts, std::size(exts));
       extensions.push_back(ref);
     }
     break;
   default:
     break;
   }
 }
 
 void ScalarType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     Optional<StorageClass> storage) {
   unsigned bitwidth = getIntOrFloatBitWidth();
 
   // 8- or 16-bit integer/floating-point numbers will require extra capabilities
   // to appear in interface storage classes. See SPV_KHR_16bit_storage and
   // SPV_KHR_8bit_storage for more details.
 
 #define STORAGE_CASE(storage, cap8, cap16)                                     \
   case StorageClass::storage: {                                                \
     if (bitwidth == 8) {                                                       \
       static const Capability caps[] = {Capability::cap8};                     \
-      ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));              \
+      ArrayRef<Capability> ref(caps, std::size(caps));                         \
       capabilities.push_back(ref);                                             \
       return;                                                                  \
     }                                                                          \
     if (bitwidth == 16) {                                                      \
       static const Capability caps[] = {Capability::cap16};                    \
-      ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));              \
+      ArrayRef<Capability> ref(caps, std::size(caps));                         \
       capabilities.push_back(ref);                                             \
       return;                                                                  \
     }                                                                          \
     /* For 64-bit integers/floats, Int64/Float64 enables support for all */    \
     /* storage classes. Fall through to the next section. */                   \
   } break
 
   // This part only handles the cases where special bitwidths appearing in
   // interface storage classes.
   if (storage) {
     switch (*storage) {
       STORAGE_CASE(PushConstant, StoragePushConstant8, StoragePushConstant16);
       STORAGE_CASE(StorageBuffer, StorageBuffer8BitAccess,
                    StorageBuffer16BitAccess);
       STORAGE_CASE(Uniform, UniformAndStorageBuffer8BitAccess,
                    StorageUniform16);
     case StorageClass::Input:
     case StorageClass::Output: {
       if (bitwidth == 16) {
         static const Capability caps[] = {Capability::StorageInputOutput16};
-        ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));
+        ArrayRef<Capability> ref(caps, std::size(caps));
         capabilities.push_back(ref);
         return;
       }
       break;
     }
     default:
       break;
     }
   }
 #undef STORAGE_CASE
 
   // For other non-interface storage classes, require a different set of
   // capabilities for special bitwidths.
 
 #define WIDTH_CASE(type, width)                                                \
   case width: {                                                                \
     static const Capability caps[] = {Capability::type##width};                \
-    ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));                \
+    ArrayRef<Capability> ref(caps, std::size(caps));                           \
     capabilities.push_back(ref);                                               \
   } break
 
   if (auto intType = dyn_cast<IntegerType>()) {
     switch (bitwidth) {
       WIDTH_CASE(Int, 8);
       WIDTH_CASE(Int, 16);
       WIDTH_CASE(Int, 64);
void MatrixType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
   getColumnType().cast<SPIRVType>().getExtensions(extensions, storage);
 }
 
 void MatrixType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     Optional<StorageClass> storage) {
   {
     static const Capability caps[] = {Capability::Matrix};
-    ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));
+    ArrayRef<Capability> ref(caps, std::size(caps));
     capabilities.push_back(ref);
   }
   // Add any capabilities associated with the underlying vectors (i.e., columns)
   getColumnType().cast<SPIRVType>().getCapabilities(capabilities, storage);
 }
 
 //===----------------------------------------------------------------------===//
 // SPIR-V Dialect
 //===----------------------------------------------------------------------===//
 
 void SPIRVDialect::registerTypes() {
   addTypes<ArrayType, CooperativeMatrixNVType, ImageType, JointMatrixINTELType,
            MatrixType, PointerType, RuntimeArrayType, SampledImageType,
            StructType>();
 }