[mlir][ODS] Add `constBuilderCall` to `Dense*ArrayAttr`s

[zero9178]

Summary

These are useful in builders of Ops taking DenseArrayAttrs or for use in Rewriter, to create constant instances.

[Mogball]

thanks!

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 def LLVM_InsertValueOp : LLVM_Op<
     "insertvalue", [NoSideEffect, AllTypesMatch<["container", "res"]>]> {
   let summary = "Insert a value into an LLVM struct.";
 
   let arguments = (ins LLVM_AnyAggregate:$container, LLVM_PrimitiveType:$value,
                        DenseI64ArrayAttr:$position);
   let results = (outs LLVM_AnyAggregate:$res);
 
-  let builders = [
-    OpBuilder<(ins "Value":$container, "Value":$value,
-                   "ArrayRef<int64_t>":$position)>
-  ];
-
   let assemblyFormat = [{
     $value `,` $container `` $position attr-dict `:` type($container)
     custom<InsertExtractValueElementType>(type($value), ref(type($container)),
                                           ref($position))
   }];
 
   let hasVerifier = 1;
 

mlir/include/mlir/IR/Builders.h

public:
   /// Tensor-typed DenseIntElementsAttr getters. `values` can be empty.
   /// These are generally preferable for representing general lists of integers
   /// as attributes.
   DenseIntElementsAttr getI32TensorAttr(ArrayRef<int32_t> values);
   DenseIntElementsAttr getI64TensorAttr(ArrayRef<int64_t> values);
   DenseIntElementsAttr getIndexTensorAttr(ArrayRef<int64_t> values);
 
   /// Tensor-typed DenseArrayAttr getters.
+  DenseBoolArrayAttr getDenseBoolArrayAttr(ArrayRef<bool> values);
   DenseI8ArrayAttr getDenseI8ArrayAttr(ArrayRef<int8_t> values);
   DenseI16ArrayAttr getDenseI16ArrayAttr(ArrayRef<int16_t> values);
   DenseI32ArrayAttr getDenseI32ArrayAttr(ArrayRef<int32_t> values);
   DenseI64ArrayAttr getDenseI64ArrayAttr(ArrayRef<int64_t> values);
   DenseF32ArrayAttr getDenseF32ArrayAttr(ArrayRef<float> values);
   DenseF64ArrayAttr getDenseF64ArrayAttr(ArrayRef<double> values);
 
   ArrayAttr getAffineMapArrayAttr(ArrayRef<AffineMap> values);

mlir/include/mlir/IR/OpBase.td

class IntElementsAttrBase<Pred condition, string summary> :
   let convertFromStorage = "$_self";
 }
 
 class DenseArrayAttrBase<string denseAttrName, string cppType, string summaryName> :
     ElementsAttrBase<CPred<"$_self.isa<::mlir::" # denseAttrName # ">()">,
                      summaryName # " dense array attribute"> {
   let storageType = "::mlir::" # denseAttrName;
   let returnType = "::llvm::ArrayRef<" # cppType # ">";
+  let constBuilderCall = "$_builder.get" # denseAttrName # "($0)";
 }
 def DenseBoolArrayAttr : DenseArrayAttrBase<"DenseBoolArrayAttr", "bool", "i1">;
 def DenseI8ArrayAttr : DenseArrayAttrBase<"DenseI8ArrayAttr", "int8_t", "i8">;
 def DenseI16ArrayAttr : DenseArrayAttrBase<"DenseI16ArrayAttr", "int16_t", "i16">;
 def DenseI32ArrayAttr : DenseArrayAttrBase<"DenseI32ArrayAttr", "int32_t", "i32">;
 def DenseI64ArrayAttr : DenseArrayAttrBase<"DenseI64ArrayAttr", "int64_t", "i64">;
 def DenseF32ArrayAttr : DenseArrayAttrBase<"DenseF32ArrayAttr", "float", "f32">;
 def DenseF64ArrayAttr : DenseArrayAttrBase<"DenseF64ArrayAttr", "double", "f64">;

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

LogicalResult InsertValueOp::verify() {
   if (getValue().getType() != valueType)
     return emitOpError() << "Type mismatch: cannot insert "
                          << getValue().getType() << " into "
                          << getContainer().getType();
 
   return success();
 }
 
-void InsertValueOp::build(OpBuilder &builder, OperationState &state,
-                          Value container, Value value,
-                          ArrayRef<int64_t> position) {
-  build(builder, state, container.getType(), container, value,
-        builder.getAttr<DenseI64ArrayAttr>(position));
-}
-
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult ReturnOp::verify() {
   auto parent = (*this)->getParentOfType<LLVMFuncOp>();
   if (!parent)
     return success();

mlir/lib/IR/Builders.cpp

 }
 
 DenseIntElementsAttr Builder::getIndexVectorAttr(ArrayRef<int64_t> values) {
   return DenseIntElementsAttr::get(
       VectorType::get(static_cast<int64_t>(values.size()), getIndexType()),
       values);
 }
 
+DenseBoolArrayAttr Builder::getDenseBoolArrayAttr(ArrayRef<bool> values) {
+  return DenseBoolArrayAttr::get(context, values);
+}
+
 DenseI8ArrayAttr Builder::getDenseI8ArrayAttr(ArrayRef<int8_t> values) {
   return DenseI8ArrayAttr::get(context, values);
 }
 
 DenseI16ArrayAttr Builder::getDenseI16ArrayAttr(ArrayRef<int16_t> values) {
   return DenseI16ArrayAttr::get(context, values);
 }