[mlir][core] Attribute vector

[Mogball]

Summary

PoC of using an attribute vector (and some other optimizations).

[Mogball]

clang-format

[Mogball]

Remove fallback subrange

[ftynse]

flang/include/flang/Optimizer/Builder/FIRBuilder.h

129

llvm::mlir:: namespace looks incorrect here

[Mogball]

flang/include/flang/Optimizer/Builder/FIRBuilder.h

129

This is just a PoC patch so that others (i.e. Chris) can test the performance on whatever benchmarks they have available. But, yeah, I should probably make sure flang compiles (some tests will still fail).

[Mogball]

Fix flang build

flang/include/flang/Optimizer/Builder/FIRBuilder.h

public:
 
   /// Create a temporary. A temp is allocated using `fir.alloca` and can be read
   /// and written using `fir.load` and `fir.store`, resp.  The temporary can be
   /// given a name via a front-end `Symbol` or a `StringRef`.
   mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
                               llvm::StringRef name = {},
                               mlir::ValueRange shape = {},
                               mlir::ValueRange lenParams = {},
-                              llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
+                              mlir::AttributeRange attrs = {});
 
   /// Create an unnamed and untracked temporary on the stack.
   mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
                               mlir::ValueRange shape) {
     return createTemporary(loc, type, llvm::StringRef{}, shape);
   }
 
   mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
-                              llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                              mlir::AttributeRange attrs) {
     return createTemporary(loc, type, llvm::StringRef{}, {}, {}, attrs);
   }
 
   mlir::Value createTemporary(mlir::Location loc, mlir::Type type,
                               llvm::StringRef name,
-                              llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                              mlir::AttributeRange attrs) {
     return createTemporary(loc, type, name, {}, {}, attrs);
   }
 
   /// Create a global value.
   fir::GlobalOp createGlobal(mlir::Location loc, mlir::Type type,
                              llvm::StringRef name,
                              mlir::StringAttr linkage = {},
                              mlir::Attribute value = {}, bool isConst = false);

flang/include/flang/Optimizer/Dialect/FIROps.td

class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 }
 
 def fir_OneResultOpBuilder : OpBuilder<(ins
     "mlir::Type":$resultType,
     "mlir::ValueRange":$operands,
-    CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
+    CArg<"mlir::AttributeRange", "{}">:$attributes),
   [{
     if (resultType)
       $_state.addTypes(resultType);
     $_state.addOperands(operands);
     $_state.addAttributes(attributes);
   }]>;
 
 // Base class of FIR operations that return 1 result
def fir_AllocaOp : fir_Op<"alloca", [AttrSizedOperandSegments,
   let parser =
       "return parseAllocatableOp(wrapAllocaResultType, parser, result);";
   let printer = "printAllocatableOp(p, (*this));";
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       "llvm::StringRef":$bindcName, CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       "llvm::StringRef":$bindcName, "bool":$pinned,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       "bool":$pinned, CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType, "bool":$pinned,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>];
 
   let verifier = "return ::verify(*this);";
 
   let extraClassDeclaration = [{
     mlir::Type getAllocatedType();
     bool hasLenParams() { return !typeparams().empty(); }
     bool hasShapeOperands() { return !shape().empty(); }
     unsigned numLenParams() { return typeparams().size(); }
def fir_AllocMemOp : fir_Op<"allocmem",
   let parser =
       "return parseAllocatableOp(wrapAllocMemResultType, parser, result);";
   let printer = "printAllocatableOp(p, (*this));";
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$in_type, "llvm::StringRef":$uniq_name,
       "llvm::StringRef":$bindc_name, CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$in_type, "llvm::StringRef":$uniq_name,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$in_type,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>];
 
   let verifier = "return ::verify(*this);";
 
   let extraClassDeclaration = [{
     mlir::Type getAllocatedType();
     bool hasLenParams() { return !typeparams().empty(); }
     bool hasShapeOperands() { return !shape().empty(); }
     unsigned numLenParams() { return typeparams().size(); }

 class fir_IntegralSwitchTerminatorOp<string mnemonic,
     list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
 
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<(ins "mlir::Value":$selector,
     "llvm::ArrayRef<int64_t>":$compareOperands,
     "llvm::ArrayRef<mlir::Block *>":$destinations,
     CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
-    CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
+    CArg<"mlir::AttributeRange", "{}">:$attributes),
     [{
       $_state.addOperands(selector);
       llvm::SmallVector<mlir::Attribute> ivalues;
       for (auto iv : compareOperands)
         ivalues.push_back($_builder.getI64IntegerAttr(iv));
       ivalues.push_back($_builder.getUnitAttr());
       $_state.addAttribute(getCasesAttr(), $_builder.getArrayAttr(ivalues));
       const auto count = destinations.size();
def fir_SelectCaseOp : fir_SwitchTerminatorOp<"select_case"> {
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "mlir::Value":$selector,
       "llvm::ArrayRef<mlir::Attribute>":$compareAttrs,
       "llvm::ArrayRef<mlir::ValueRange>":$cmpOperands,
       "llvm::ArrayRef<mlir::Block *>":$destinations,
       CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Value":$selector,
       "llvm::ArrayRef<mlir::Attribute>":$compareAttrs,
       "llvm::ArrayRef<mlir::Value>":$cmpOpList,
       "llvm::ArrayRef<mlir::Block *>":$destinations,
       CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>];
 
   let parser = "return parseSelectCase(parser, result);";
 
   let printer = "::print(p, *this);";
 
   let verifier = "return ::verify(*this);";
 
   let extraClassDeclaration = extraSwitchClassDeclaration#[{
let description = [{
     ```
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<(ins "mlir::Value":$selector,
     "llvm::ArrayRef<mlir::Attribute>":$typeOperands,
     "llvm::ArrayRef<mlir::Block *>":$destinations,
     CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
-    CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
+    CArg<"mlir::AttributeRange", "{}">:$attributes)>];
 
   let parser = "return parseSelectType(parser, result);";
 
   let printer = "::print(p, *this);";
 
   let verifier = "return ::verify(*this);";
 
   let extraClassDeclaration = extraSwitchClassDeclaration;
def fir_DoLoopOp : region_Op<"do_loop",
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
       "mlir::Value":$step, CArg<"bool", "false">:$unordered,
       CArg<"bool", "false">:$finalCountValue,
       CArg<"mlir::ValueRange", "llvm::None">:$iterArgs,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = [{
     mlir::Value getInductionVar() { return getBody()->getArgument(0); }
     mlir::OpBuilder getBodyBuilder() {
       return OpBuilder(getBody(), std::prev(getBody()->end()));
     }
     mlir::Block::BlockArgListType getRegionIterArgs() {
def fir_IterWhileOp : region_Op<"iterate_while",
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
       "mlir::Value":$step, "mlir::Value":$iterate,
       CArg<"bool", "false">:$finalCountValue,
       CArg<"mlir::ValueRange", "llvm::None">:$iterArgs,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>
+      CArg<"mlir::AttributeRange", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getFinalValueAttrName() {
       return "finalValue";
     }
     mlir::Block *getBody() { return &region().front(); }
     mlir::Value getIterateVar() { return getBody()->getArgument(1); }
def fir_GlobalOp : fir_Op<"global", [IsolatedFromAbove, Symbol]> {
 
   let parser = "return parseGlobalOp(parser, result);";
 
   let printer = "::print(p, *this);";
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       CArg<"mlir::StringAttr", "{}">:$linkage,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type, CArg<"mlir::StringAttr", "{}">:$linkage,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       "mlir::Attribute":$initVal, CArg<"mlir::StringAttr", "{}">:$linkage,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type, "mlir::Attribute":$initVal,
       CArg<"mlir::StringAttr", "{}">:$linkage,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
+      CArg<"mlir::AttributeRange", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef symbolAttrName() { return "symref"; }
     static constexpr llvm::StringRef getConstantAttrName() {
       return "constant";
     }
     static constexpr llvm::StringRef linkageAttrName() { return "linkName"; }
def fir_DispatchTableOp : fir_Op<"dispatch_table",
 
   let verifier = "return ::verify(*this);";
 
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
-      CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs),
+      CArg<"mlir::AttributeRange", "{}">:$attrs),
     [{
       $_state.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                            $_builder.getStringAttr(name));
       $_state.addAttributes(attrs);
     }]>
   ];
 
   let extraClassDeclaration = [{

flang/include/flang/Optimizer/Dialect/FIROpsSupport.h

 }
 
 /// Get or create a FuncOp in a module.
 ///
 /// If `module` already contains FuncOp `name`, it is returned. Otherwise, a new
 /// FuncOp is created, and that new FuncOp is returned.
 mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                           llvm::StringRef name, mlir::FunctionType type,
-                          llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
+                          mlir::AttributeRange attrs = {});
 
 /// Get or create a GlobalOp in a module.
 fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
                              llvm::StringRef name, mlir::Type type,
-                             llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
+                             mlir::AttributeRange attrs = {});
 
 /// Attribute to mark Fortran entities with the CONTIGUOUS attribute.
 constexpr llvm::StringRef getContiguousAttrName() { return "fir.contiguous"; }
 /// Attribute to mark Fortran entities with the OPTIONAL attribute.
 constexpr llvm::StringRef getOptionalAttrName() { return "fir.optional"; }
 
 /// Attribute to mark Fortran entities with the TARGET attribute.
 static constexpr llvm::StringRef getTargetAttrName() { return "fir.target"; }

flang/lib/Optimizer/Builder/FIRBuilder.cpp

mlir::Block *fir::FirOpBuilder::getAllocaBlock() {
   // auto iface =
   //     getRegion().getParentOfType<mlir::omp::OutlineableOpenMPOpInterface>();
   // return iface ? iface.getAllocaBlock() : getEntryBlock();
   return getEntryBlock();
 }
 
 /// Create a temporary variable on the stack. Anonymous temporaries have no
 /// `name` value. Temporaries do not require a uniqued name.
-mlir::Value
-fir::FirOpBuilder::createTemporary(mlir::Location loc, mlir::Type type,
-                                   llvm::StringRef name, mlir::ValueRange shape,
+mlir::Value fir::FirOpBuilder::createTemporary(mlir::Location loc,
+                                               mlir::Type type,
+                                               llvm::StringRef name,
+                                               mlir::ValueRange shape,
                                                mlir::ValueRange lenParams,
-                                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                                               mlir::AttributeRange attrs) {
   llvm::SmallVector<mlir::Value> dynamicShape =
       elideExtentsAlreadyInType(type, shape);
   llvm::SmallVector<mlir::Value> dynamicLength =
       elideLengthsAlreadyInType(type, lenParams);
   InsertPoint insPt;
   const bool hoistAlloc = dynamicShape.empty() && dynamicLength.empty();
   if (hoistAlloc) {
     insPt = saveInsertionPoint();

flang/lib/Optimizer/Dialect/FIROps.cpp

 mlir::Type fir::AllocaOp::getRefTy(mlir::Type ty) {
   return ReferenceType::get(ty);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           llvm::StringRef uniqName, mlir::ValueRange typeparams,
                           mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
   build(builder, result, wrapAllocaResultType(inType), inType, nameAttr, {},
         /*pinned=*/false, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           llvm::StringRef uniqName, bool pinned,
                           mlir::ValueRange typeparams, mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
   build(builder, result, wrapAllocaResultType(inType), inType, nameAttr, {},
         pinned, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           llvm::StringRef uniqName, llvm::StringRef bindcName,
                           mlir::ValueRange typeparams, mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   auto nameAttr =
       uniqName.empty() ? mlir::StringAttr{} : builder.getStringAttr(uniqName);
   auto bindcAttr =
       bindcName.empty() ? mlir::StringAttr{} : builder.getStringAttr(bindcName);
   build(builder, result, wrapAllocaResultType(inType), inType, nameAttr,
         bindcAttr, /*pinned=*/false, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           llvm::StringRef uniqName, llvm::StringRef bindcName,
                           bool pinned, mlir::ValueRange typeparams,
                           mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   auto nameAttr =
       uniqName.empty() ? mlir::StringAttr{} : builder.getStringAttr(uniqName);
   auto bindcAttr =
       bindcName.empty() ? mlir::StringAttr{} : builder.getStringAttr(bindcName);
   build(builder, result, wrapAllocaResultType(inType), inType, nameAttr,
         bindcAttr, pinned, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           mlir::ValueRange typeparams, mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   build(builder, result, wrapAllocaResultType(inType), inType, {}, {},
         /*pinned=*/false, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           bool pinned, mlir::ValueRange typeparams,
                           mlir::ValueRange shape,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   build(builder, result, wrapAllocaResultType(inType), inType, {}, {}, pinned,
         typeparams, shape);
   result.addAttributes(attributes);
 }
 
 static mlir::LogicalResult verify(fir::AllocaOp &op) {
   llvm::SmallVector<llvm::StringRef> visited;
   if (verifyInType(op.getInType(), visited, op.numShapeOperands()))

 mlir::Type fir::AllocMemOp::getRefTy(mlir::Type ty) {
   return HeapType::get(ty);
 }
 
 void fir::AllocMemOp::build(mlir::OpBuilder &builder,
                             mlir::OperationState &result, mlir::Type inType,
                             llvm::StringRef uniqName,
                             mlir::ValueRange typeparams, mlir::ValueRange shape,
-                            llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                            mlir::AttributeRange attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
   build(builder, result, wrapAllocMemResultType(inType), inType, nameAttr, {},
         typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocMemOp::build(mlir::OpBuilder &builder,
                             mlir::OperationState &result, mlir::Type inType,
                             llvm::StringRef uniqName, llvm::StringRef bindcName,
                             mlir::ValueRange typeparams, mlir::ValueRange shape,
-                            llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                            mlir::AttributeRange attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
   auto bindcAttr = builder.getStringAttr(bindcName);
   build(builder, result, wrapAllocMemResultType(inType), inType, nameAttr,
         bindcAttr, typeparams, shape);
   result.addAttributes(attributes);
 }
 
 void fir::AllocMemOp::build(mlir::OpBuilder &builder,
                             mlir::OperationState &result, mlir::Type inType,
                             mlir::ValueRange typeparams, mlir::ValueRange shape,
-                            llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                            mlir::AttributeRange attributes) {
   build(builder, result, wrapAllocMemResultType(inType), inType, {}, {},
         typeparams, shape);
   result.addAttributes(attributes);
 }
 
 static mlir::LogicalResult verify(fir::AllocMemOp op) {
   llvm::SmallVector<llvm::StringRef> visited;
   if (verifyInType(op.getInType(), visited, op.numShapeOperands()))

 
 void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
   getBlock().getOperations().push_back(op);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, bool isConstant, Type type,
                           Attribute initialVal, StringAttr linkage,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   result.addRegion();
   result.addAttribute(typeAttrName(result.name), mlir::TypeAttr::get(type));
   result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute(symbolAttrName(),
                       SymbolRefAttr::get(builder.getContext(), name));
   if (isConstant)
     result.addAttribute(constantAttrName(result.name), builder.getUnitAttr());
   if (initialVal)
     result.addAttribute(initValAttrName(result.name), initialVal);
   if (linkage)
     result.addAttribute(linkageAttrName(), linkage);
   result.attributes.append(attrs.begin(), attrs.end());
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, Type type, Attribute initialVal,
-                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+                          StringAttr linkage, AttributeRange attrs) {
   build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, bool isConstant, Type type,
-                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+                          StringAttr linkage, AttributeRange attrs) {
   build(builder, result, name, isConstant, type, {}, linkage, attrs);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, Type type, StringAttr linkage,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, bool isConstant, Type type,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   build(builder, result, name, isConstant, type, StringAttr{}, attrs);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
-                          StringRef name, Type type,
-                          ArrayRef<NamedAttribute> attrs) {
+                          StringRef name, Type type, AttributeRange attrs) {
   build(builder, result, name, /*isConstant=*/false, type, attrs);
 }
 
 mlir::ParseResult fir::GlobalOp::verifyValidLinkage(StringRef linkage) {
   // Supporting only a subset of the LLVM linkage types for now
   static const char *validNames[] = {"common", "internal", "linkonce", "weak"};
   return mlir::success(llvm::is_contained(validNames, linkage));
 }

 // IterWhileOp
 //===----------------------------------------------------------------------===//
 
 void fir::IterWhileOp::build(mlir::OpBuilder &builder,
                              mlir::OperationState &result, mlir::Value lb,
                              mlir::Value ub, mlir::Value step,
                              mlir::Value iterate, bool finalCountValue,
                              mlir::ValueRange iterArgs,
-                             llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                             mlir::AttributeRange attributes) {
   result.addOperands({lb, ub, step, iterate});
   if (finalCountValue) {
     result.addTypes(builder.getIndexType());
     result.addAttribute(getFinalValueAttrName(), builder.getUnitAttr());
   }
   result.addTypes(iterate.getType());
   result.addOperands(iterArgs);
   for (auto v : iterArgs)

 //===----------------------------------------------------------------------===//
 // DoLoopOp
 //===----------------------------------------------------------------------===//
 
 void fir::DoLoopOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Value lb,
                           mlir::Value ub, mlir::Value step, bool unordered,
                           bool finalCountValue, mlir::ValueRange iterArgs,
-                          llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                          mlir::AttributeRange attributes) {
   result.addOperands({lb, ub, step});
   result.addOperands(iterArgs);
   if (finalCountValue) {
     result.addTypes(builder.getIndexType());
     result.addAttribute(finalValueAttrName(result.name), builder.getUnitAttr());
   }
   for (auto v : iterArgs)
     result.addTypes(v.getType());
static A getSubOperands(unsigned pos, A allArgs,
   return allArgs.slice(start, (*(ranges.begin() + pos)).getZExtValue(),
                        std::forward<AdditionalArgs>(additionalArgs)...);
 }
 
 static mlir::MutableOperandRange
 getMutableSuccessorOperands(unsigned pos, mlir::MutableOperandRange operands,
                             StringRef offsetAttr) {
   Operation *owner = operands.getOwner();
-  NamedAttribute targetOffsetAttr =
-      *owner->getAttrDictionary().getNamed(offsetAttr);
+  NamedAttribute targetOffsetAttr = *owner->getAttrs().getNamed(offsetAttr);
   return getSubOperands(
       pos, operands, targetOffsetAttr.second.cast<DenseIntElementsAttr>(),
       mlir::MutableOperandRange::OperandSegment(pos, targetOffsetAttr));
 }
 
 static unsigned denseElementsSize(mlir::DenseIntElementsAttr attr) {
   return attr.getNumElements();
 }

 
 void fir::SelectCaseOp::build(mlir::OpBuilder &builder,
                               mlir::OperationState &result,
                               mlir::Value selector,
                               llvm::ArrayRef<mlir::Attribute> compareAttrs,
                               llvm::ArrayRef<mlir::ValueRange> cmpOperands,
                               llvm::ArrayRef<mlir::Block *> destinations,
                               llvm::ArrayRef<mlir::ValueRange> destOperands,
-                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                              mlir::AttributeRange attributes) {
   result.addOperands(selector);
   result.addAttribute(getCasesAttr(), builder.getArrayAttr(compareAttrs));
   llvm::SmallVector<int32_t> operOffs;
   int32_t operSize = 0;
   for (auto attr : compareAttrs) {
     if (attr.isa<fir::ClosedIntervalAttr>()) {
       operOffs.push_back(2);
       operSize += 2;

 /// partitioning is unchecked, so can go awry on bad input.
 void fir::SelectCaseOp::build(mlir::OpBuilder &builder,
                               mlir::OperationState &result,
                               mlir::Value selector,
                               llvm::ArrayRef<mlir::Attribute> compareAttrs,
                               llvm::ArrayRef<mlir::Value> cmpOpList,
                               llvm::ArrayRef<mlir::Block *> destinations,
                               llvm::ArrayRef<mlir::ValueRange> destOperands,
-                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                              mlir::AttributeRange attributes) {
   llvm::SmallVector<mlir::ValueRange> cmpOpers;
   auto iter = cmpOpList.begin();
   for (auto &attr : compareAttrs) {
     if (attr.isa<fir::ClosedIntervalAttr>()) {
       cmpOpers.push_back(mlir::ValueRange({iter, iter + 2}));
       iter += 2;
     } else if (attr.isa<UnitAttr>()) {
       cmpOpers.push_back(mlir::ValueRange{});

 }
 
 void fir::SelectTypeOp::build(mlir::OpBuilder &builder,
                               mlir::OperationState &result,
                               mlir::Value selector,
                               llvm::ArrayRef<mlir::Attribute> typeOperands,
                               llvm::ArrayRef<mlir::Block *> destinations,
                               llvm::ArrayRef<mlir::ValueRange> destOperands,
-                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
+                              mlir::AttributeRange attributes) {
   result.addOperands(selector);
   result.addAttribute(getCasesAttr(), builder.getArrayAttr(typeOperands));
   const auto count = destinations.size();
   for (mlir::Block *dest : destinations)
     result.addSuccessors(dest);
   const auto opCount = destOperands.size();
   llvm::SmallVector<int32_t> argOffs;
   int32_t sumArgs = 0;

 
 bool fir::isReferenceLike(mlir::Type type) {
   return type.isa<fir::ReferenceType>() || type.isa<fir::HeapType>() ||
          type.isa<fir::PointerType>();
 }
 
 mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                                StringRef name, mlir::FunctionType type,
-                               llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                               mlir::AttributeRange attrs) {
   if (auto f = module.lookupSymbol<mlir::FuncOp>(name))
     return f;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   modBuilder.setInsertionPointToEnd(module.getBody());
   auto result = modBuilder.create<mlir::FuncOp>(loc, name, type, attrs);
   result.setVisibility(mlir::SymbolTable::Visibility::Private);
   return result;
 }
 
 fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
                                   StringRef name, mlir::Type type,
-                                  llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+                                  mlir::AttributeRange attrs) {
   if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
     return g;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   auto result = modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
   result.setVisibility(mlir::SymbolTable::Visibility::Private);
   return result;
 }
 

mlir/docs/DeclarativeRewrites.md

 In the above, we are using `BOp`'s result for building `COp`.
 
 #### Building operations
 
 Given that `COp` was specified with table-driven op definition, there will be
 several `build()` methods generated for it. One of them has aggregated
 parameters for result types, operands, and attributes in the signature: `void
 COp::build(..., ArrayRef<Type> resultTypes, Array<Value> operands,
-ArrayRef<NamedAttribute> attr)`. The pattern in the above calls this `build()`
-method for constructing the `COp`.
+AttributeRange attr)`. The pattern in the above calls this `build()` method for
+constructing the `COp`.
 
 In general, arguments in the result pattern will be passed directly to the
 `build()` method to leverage the auto-generated `build()` method, list them in
 the pattern by following the exact same order as the ODS `arguments` definition.
 Otherwise, a custom `build()` method that matches the argument list is required.
 
 Right now all ODS-generated `build()` methods require specifying the result
 type(s), unless the op has known traits like `SameOperandsAndResultType` that we

mlir/docs/OpDefinitions.md

 
 ### Operation traits and constraints
 
 Traits are operation properties that affect syntax or semantics. MLIR C++ models
 various traits in the `mlir::OpTrait` namespace.
 
 Both operation traits, [interfaces](Interfaces.md/#utilizing-the-ods-framework),
 and constraints involving multiple operands/attributes/results are provided as
-the third template parameter to the `Op` class. They should be deriving from
-the `OpTrait` class. See [Constraints](#constraints) for more information.
+the third template parameter to the `Op` class. They should be deriving from the
+`OpTrait` class. See [Constraints](#constraints) for more information.
 
 ### Builder methods
 
 For each operation, there are a few builders automatically generated based on
 the arguments and returns types. For example, given the following op definition:
 
 ```tablegen
 def MyOp : ... {

 
 The following builders are generated:
 
 ```c++
 // All result-types/operands/attributes have one aggregate parameter.
 static void build(OpBuilder &odsBuilder, OperationState &odsState,
                   ArrayRef<Type> resultTypes,
                   ValueRange operands,
-                  ArrayRef<NamedAttribute> attributes);
+                  AttributeRange attributes);
 
 // Each result-type/operand/attribute has a separate parameter. The parameters
 // for attributes are of mlir::Attribute types.
 static void build(OpBuilder &odsBuilder, OperationState &odsState,
                   Type i32_result, Type f32_result, ...,
                   Value i32_operand, Value f32_operand, ...,
                   IntegerAttr i32_attr, FloatAttr f32_attr, ...);
 

 static void build(OpBuilder &odsBuilder, OperationState &odsState,
                   ArrayRef<Type> resultTypes,
                   Value i32_operand, Value f32_operand, ...,
                   IntegerAttr i32_attr, FloatAttr f32_attr, ...);
 
 // All operands/attributes have aggregate parameters.
 // Generated if return type can be inferred.
 static void build(OpBuilder &odsBuilder, OperationState &odsState,
-                  ValueRange operands, ArrayRef<NamedAttribute> attributes);
+                  ValueRange operands, AttributeRange attributes);
 
 // (And manually specified builders depending on the specific op.)
 ```
 
 The first form provides basic uniformity so that we can create ops using the
 same form regardless of the exact op. This is particularly useful for
 implementing declarative pattern rewrites.
 

 ### Custom parser and printer methods
 
 Functions to parse and print the operation's custom assembly form.
 
 ### Custom verifier code
 
 Verification code will be automatically generated for
 [constraints](#constraints) specified on various entities of the op. To perform
-_additional_ verification, you can use
+*additional* verification, you can use
 
 ```tablegen
 let verifier = [{
   ...
 }];
 ```
 
 Code placed in `verifier` will be called after the auto-generated verification
def ReturnOp : ... {
   // We only print the operands and types if there are a non-zero number
   // of operands.
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 ```
 
 ##### Unit Attributes
 
-In MLIR, the [`unit` Attribute](Dialects/Builtin.md/#unitattr) is special in that it
-only has one possible value, i.e. it derives meaning from its existence. When a
-unit attribute is used to anchor an optional group and is not the first element
-of the group, the presence of the unit attribute can be directly correlated with
-the presence of the optional group itself. As such, in these situations the unit
-attribute will not be printed or present in the output and will be automatically
-inferred when parsing by the presence of the optional group itself.
+In MLIR, the [`unit` Attribute](Dialects/Builtin.md/#unitattr) is special in
+that it only has one possible value, i.e. it derives meaning from its existence.
+When a unit attribute is used to anchor an optional group and is not the first
+element of the group, the presence of the unit attribute can be directly
+correlated with the presence of the optional group itself. As such, in these
+situations the unit attribute will not be printed or present in the output and
+will be automatically inferred when parsing by the presence of the optional
+group itself.
 
 For example, the following operation:
 
 ```tablegen
 def FooOp : ... {
   let arguments = (ins UnitAttr:$is_read_only);
 
   let assemblyFormat = "attr-dict (`is_read_only` $is_read_only^)?";

 
 This means the qualified name of the generated C++ class does not necessarily
 match exactly with the operation name as explained in
 [Operation name](#operation-name). This is to allow flexible naming to satisfy
 coding style requirements.
 
 #### Operand adaptors
 
-For each operation, we automatically generate an _operand adaptor_. This class
+For each operation, we automatically generate an *operand adaptor*. This class
 solves the problem of accessing operands provided as a list of `Value`s without
 using "magic" constants. The operand adaptor takes a reference to an array of
 `Value` and provides methods with the same names as those in the operation class
 to access them. For example, for a binary arithmetic operation, it may provide
 `.lhs()` to access the first operand and `.rhs()` to access the second operand.
 
 The operand adaptor class lives in the same namespace as the operation class,
 and has the name of the operation followed by `Adaptor` as well as an alias

 `$_builder`, `$_op`, and `$_self`:
 
 *   `$_builder` will be replaced by a `mlir::Builder` instance so that you can
     access common build methods.
 *   `$_op` will be replaced by the current operation so that you can access
     information of the current operation.
 *   `$_self` will be replaced with the entity this predicate is attached to.
     E.g., `BoolAttr` is an attribute constraint that wraps a
-    `CPred<"$_self.isa<BoolAttr>()">`. Then for `BoolAttr:$attr`,`$_self` will be
-    replaced by `$attr`. For type constraints, it's a little bit special since
-    we want the constraints on each type definition reads naturally and we want
-    to attach type constraints directly to an operand/result, `$_self` will be
-    replaced by the operand/result's type. E.g., for `F32` in `F32:$operand`,
+    `CPred<"$_self.isa<BoolAttr>()">`. Then for `BoolAttr:$attr`,`$_self` will
+    be replaced by `$attr`. For type constraints, it's a little bit special
+    since we want the constraints on each type definition reads naturally and we
+    want to attach type constraints directly to an operand/result, `$_self` will
+    be replaced by the operand/result's type. E.g., for `F32` in `F32:$operand`,
     its `$_self` will be expanded as `operand(...).getType()`.
 
 TODO: Reconsider the leading symbol for special placeholders. Eventually we want
 to allow referencing operand/result `$-name`s; such `$-name`s can start with
 underscore.
 
 For example, to write an attribute `attr` is an `IntegerAttr`, in C++ you can
 just call `attr.isa<IntegerAttr>()`. The code can be wrapped in a `CPred` as

 common C++ [attribute classes][AttrClasses] defined in MLIR's core IR library
 and one is free to define dialect-specific attribute classes. ODS allows one to
 use these attributes in TableGen to define operations, potentially with more
 fine-grained constraints. For example, `StrAttr` directly maps to `StringAttr`;
 `F32Attr`/`F64Attr` requires the `FloatAttr` to additionally be of a certain
 bitwidth.
 
 ODS attributes are defined as having a storage type (corresponding to a backing
-`mlir::Attribute` that _stores_ the attribute), a return type (corresponding to
-the C++ _return_ type of the generated helper getters) as well as a method
-to convert between the internal storage and the helper method.
+`mlir::Attribute` that *stores* the attribute), a return type (corresponding to
+the C++ *return* type of the generated helper getters) as well as a method to
+convert between the internal storage and the helper method.
 
 ### Attribute decorators
 
 There are a few important attribute adapters/decorators/modifiers that can be
 applied to ODS attributes to specify common additional properties like
 optionality, default values, etc.:
 
 *   `DefaultValuedAttr`: specifies the
llvm::Optional<MyBitEnum> symbolizeMyBitEnum(uint32_t value) {
 
   if (value & ~(1u | 2u | 4u)) return llvm::None;
   return static_cast<MyBitEnum>(value);
 }
 ```
 
 ## Type Definitions
 
-MLIR defines the `TypeDef` class hierarchy to enable generation of data types from
-their specifications. A type is defined by specializing the `TypeDef` class with
-concrete contents for all the fields it requires. For example, an integer type
-could be defined as:
+MLIR defines the `TypeDef` class hierarchy to enable generation of data types
+from their specifications. A type is defined by specializing the `TypeDef` class
+with concrete contents for all the fields it requires. For example, an integer
+type could be defined as:
 
 ```tablegen
 // All of the types will extend this class.
 class Test_Type<string name> : TypeDef<Test_Dialect, name> { }
 
 // An alternate int type.
 def IntegerType : Test_Type<"TestInteger"> {
   let mnemonic = "int";

 class MyType : /*...*/ {
   /*...*/
   static MyType get(::mlir::MLIRContext *context, int intParam);
 };
 ```
 
 This builder is identical to the one that will be automatically generated for
 `MyType`. The `context` parameter is implicitly added by the generator, and is
-used when building the Type instance (with `Base::get`). The distinction
-here is that we can provide the implementation of this `get` method. With this
-style of builder definition only the declaration is generated, the implementor
-of `MyType` will need to provide a definition of `MyType::get`.
+used when building the Type instance (with `Base::get`). The distinction here is
+that we can provide the implementation of this `get` method. With this style of
+builder definition only the declaration is generated, the implementor of
+`MyType` will need to provide a definition of `MyType::get`.
 
 The second builder will generate the declaration of a builder method that looks
 like:
 
 ```tablegen
   let builders = [
     TypeBuilder<(ins CArg<"int", "0">:$intParam)>,
   ];

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     auto loc = op->getLoc();
     lowerOpToLoops(
         op, operands, rewriter,
         [loc](OpBuilder &builder, ValueRange memRefOperands,
               ValueRange loopIvs) {
           // Generate an adaptor for the remapped operands of the BinaryOp. This
           // allows for using the nice named accessors that are generated by the
           // ODS.
-          typename BinaryOp::Adaptor binaryAdaptor(memRefOperands);
+          typename BinaryOp::Adaptor binaryAdaptor(builder.getContext(),
+                                                   memRefOperands);
 
           // Generate loads for the element of 'lhs' and 'rhs' at the inner
           // loop.
           auto loadedLhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.lhs(), loopIvs);
           auto loadedRhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.rhs(), loopIvs);
 
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     auto loc = op->getLoc();
     lowerOpToLoops(op, operands, rewriter,
                    [loc](OpBuilder &builder, ValueRange memRefOperands,
                          ValueRange loopIvs) {
                      // Generate an adaptor for the remapped operands of the
                      // TransposeOp. This allows for using the nice named
                      // accessors that are generated by the ODS.
-                     toy::TransposeOpAdaptor transposeAdaptor(memRefOperands);
+                     toy::TransposeOpAdaptor transposeAdaptor(
+                         builder.getContext(), memRefOperands);
                      Value input = transposeAdaptor.input();
 
                      // Transpose the elements by generating a load from the
                      // reverse indices.
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
                      return builder.create<AffineLoadOp>(loc, input,
                                                          reverseIvs);
                    });

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     auto loc = op->getLoc();
     lowerOpToLoops(
         op, operands, rewriter,
         [loc](OpBuilder &builder, ValueRange memRefOperands,
               ValueRange loopIvs) {
           // Generate an adaptor for the remapped operands of the BinaryOp. This
           // allows for using the nice named accessors that are generated by the
           // ODS.
-          typename BinaryOp::Adaptor binaryAdaptor(memRefOperands);
+          typename BinaryOp::Adaptor binaryAdaptor(builder.getContext(),
+                                                   memRefOperands);
 
           // Generate loads for the element of 'lhs' and 'rhs' at the inner
           // loop.
           auto loadedLhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.lhs(), loopIvs);
           auto loadedRhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.rhs(), loopIvs);
 
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     auto loc = op->getLoc();
     lowerOpToLoops(op, operands, rewriter,
                    [loc](OpBuilder &builder, ValueRange memRefOperands,
                          ValueRange loopIvs) {
                      // Generate an adaptor for the remapped operands of the
                      // TransposeOp. This allows for using the nice named
                      // accessors that are generated by the ODS.
-                     toy::TransposeOpAdaptor transposeAdaptor(memRefOperands);
+                     toy::TransposeOpAdaptor transposeAdaptor(
+                         builder.getContext(), memRefOperands);
                      Value input = transposeAdaptor.input();
 
                      // Transpose the elements by generating a load from the
                      // reverse indices.
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
                      return builder.create<AffineLoadOp>(loc, input,
                                                          reverseIvs);
                    });

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     auto loc = op->getLoc();
     lowerOpToLoops(
         op, operands, rewriter,
         [loc](OpBuilder &builder, ValueRange memRefOperands,
               ValueRange loopIvs) {
           // Generate an adaptor for the remapped operands of the BinaryOp. This
           // allows for using the nice named accessors that are generated by the
           // ODS.
-          typename BinaryOp::Adaptor binaryAdaptor(memRefOperands);
+          typename BinaryOp::Adaptor binaryAdaptor(builder.getContext(),
+                                                   memRefOperands);
 
           // Generate loads for the element of 'lhs' and 'rhs' at the inner
           // loop.
           auto loadedLhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.lhs(), loopIvs);
           auto loadedRhs =
               builder.create<AffineLoadOp>(loc, binaryAdaptor.rhs(), loopIvs);
 
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     auto loc = op->getLoc();
     lowerOpToLoops(op, operands, rewriter,
                    [loc](OpBuilder &builder, ValueRange memRefOperands,
                          ValueRange loopIvs) {
                      // Generate an adaptor for the remapped operands of the
                      // TransposeOp. This allows for using the nice named
                      // accessors that are generated by the ODS.
-                     toy::TransposeOpAdaptor transposeAdaptor(memRefOperands);
+                     toy::TransposeOpAdaptor transposeAdaptor(
+                         builder.getContext(), memRefOperands);
                      Value input = transposeAdaptor.input();
 
                      // Transpose the elements by generating a load from the
                      // reverse indices.
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
                      return builder.create<AffineLoadOp>(loc, input,
                                                          reverseIvs);
                    });

mlir/include/mlir/Conversion/LLVMCommon/Pattern.h

explicit ConvertOpToLLVMPattern(LLVMTypeConverter &typeConverter,
                                   PatternBenefit benefit = 1)
       : ConvertToLLVMPattern(SourceOp::getOperationName(),
                              &typeConverter.getContext(), typeConverter,
                              benefit) {}
 
   /// Wrappers around the RewritePattern methods that pass the derived op type.
   void rewrite(Operation *op, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const final {
-    rewrite(cast<SourceOp>(op), OpAdaptor(operands, op->getAttrDictionary()),
-            rewriter);
+    rewrite(cast<SourceOp>(op),
+            OpAdaptor(getContext(), operands, op->getAttrs()), rewriter);
   }
   LogicalResult match(Operation *op) const final {
     return match(cast<SourceOp>(op));
   }
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     return matchAndRewrite(cast<SourceOp>(op),
-                           OpAdaptor(operands, op->getAttrDictionary()),
+                           OpAdaptor(getContext(), operands, op->getAttrs()),
                            rewriter);
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
   /// NOTICE: These methods are deprecated and will be removed. All new code
   /// should use the adaptor methods below instead.
   virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
                        ConversionPatternRewriter &rewriter) const {
     llvm_unreachable("must override rewrite or matchAndRewrite");
   }
   virtual LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const {
     if (succeeded(match(op))) {
-      rewrite(op, OpAdaptor(operands, op->getAttrDictionary()), rewriter);
+      rewrite(op, OpAdaptor(getContext(), operands, op->getAttrs()), rewriter);
       return success();
     }
     return failure();
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
   virtual LogicalResult match(SourceOp op) const {

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

def Async_AwaitOp : Async_Op<"await"> {
 
   let arguments = (ins Async_AnyValueOrTokenType:$operand);
   let results = (outs Optional<AnyType>:$result);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "Value":$operand,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = [{
     Optional<Type> getResultType() {
       if (getResultTypes().empty()) return None;
       return getResultTypes()[0];
     }
   }];

mlir/include/mlir/Dialect/GPU/GPUOps.td

def GPU_GPUFuncOp : GPU_Op<"func", [HasParent<"GPUModuleOp">,
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, "FunctionType":$type,
       CArg<"TypeRange", "{}">:$workgroupAttributions,
       CArg<"TypeRange", "{}">:$privateAttributions,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = [{
     /// Returns `true` if the GPU function defined by this Op is a kernel, i.e.
     /// it is intended to be launched from host.
     bool isKernel() {
       return (*this)->getAttrOfType<UnitAttr>(
           GPUDialect::getKernelFuncAttrName()) != nullptr;

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

 }
 
 class LLVM_Builder<string builder> {
   string llvmBuilder = builder;
 }
 
 def LLVM_OneResultOpBuilder :
   OpBuilder<(ins "Type":$resultType, "ValueRange":$operands,
-    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
+    CArg<"AttributeRange", "{}">:$attributes),
   [{
     if (resultType) $_state.addTypes(resultType);
     $_state.addOperands(operands);
     for (auto namedAttr : attributes) {
       $_state.addAttribute(namedAttr.first, namedAttr.second);
     }
   }]>;
 
 def LLVM_ZeroResultOpBuilder :
   OpBuilder<(ins "ValueRange":$operands,
-    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
+    CArg<"AttributeRange", "{}">:$attributes),
   [{
     $_state.addOperands(operands);
     for (auto namedAttr : attributes) {
       $_state.addAttribute(namedAttr.first, namedAttr.second);
     }
   }]>;
 
 // Compatibility builder that takes an instance of wrapped llvm::VoidType
 // to indicate no result.
 def LLVM_VoidResultTypeOpBuilder :
   OpBuilder<(ins "Type":$resultType, "ValueRange":$operands,
-    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
+    CArg<"AttributeRange", "{}">:$attributes),
   [{
     assert(isCompatibleType(resultType) && "result must be an LLVM type");
     assert(resultType.isa<LLVMVoidType>() &&
            "for zero-result operands, only 'void' is accepted as result type");
     build($_builder, $_state, operands, attributes);
   }]>;
 
 
 // Opaque builder used for terminator operations that contain successors.
 def LLVM_TerminatorPassthroughOpBuilder :
   OpBuilder<(ins "ValueRange":$operands, "SuccessorRange":$destinations,
-    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
+    CArg<"AttributeRange", "{}">:$attributes),
   [{
     $_state.addOperands(operands);
     $_state.addSuccessors(destinations);
     $_state.addAttributes(attributes);
   }]>;
 
 // Base class for LLVM terminator operations.  All terminator operations have
 // zero results and an optional list of successors.
let description = [{
     ```
   }];
   let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
                    Variadic<LLVM_Type>,
                    DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
   let results = (outs Variadic<LLVM_Type>);
   let builders = [
     OpBuilder<(ins "LLVMFuncOp":$func, "ValueRange":$operands,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes), [{
+      CArg<"AttributeRange", "{}">:$attributes), [{
       Type resultType = func.getType().getReturnType();
       if (!resultType.isa<LLVM::LLVMVoidType>())
         $_state.addTypes(resultType);
       $_state.addAttribute("callee", SymbolRefAttr::get(func));
       $_state.addAttributes(attributes);
       $_state.addOperands(operands);
     }]>,
     OpBuilder<(ins "TypeRange":$results, "StringAttr":$callee,

 def LLVM_ExtractElementOp : LLVM_Op<"extractelement", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyVector:$vector, AnyInteger:$position);
   let results = (outs LLVM_Type:$res);
   string llvmBuilder = [{
     $res = builder.CreateExtractElement($vector, $position);
   }];
   let builders = [
     OpBuilder<(ins "Value":$vector, "Value":$position,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return parseExtractElementOp(parser, result); }];
   let printer = [{ printExtractElementOp(p, *this); }];
 }
 def LLVM_ExtractValueOp : LLVM_Op<"extractvalue", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyAggregate:$container, ArrayAttr:$position);
   let results = (outs LLVM_Type:$res);
   string llvmBuilder = [{
def LLVM_ShuffleVectorOp : LLVM_Op<"shufflevector", [NoSideEffect]> {
   let results = (outs LLVM_AnyVector:$res);
   string llvmBuilder = [{
       SmallVector<unsigned, 4> position = extractPosition($mask);
       SmallVector<int, 4> mask(position.begin(), position.end());
       $res = builder.CreateShuffleVector($v1, $v2, mask);
   }];
   let builders = [
     OpBuilder<(ins "Value":$v1, "Value":$v2, "ArrayAttr":$mask,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
   let verifier = [{
     auto type1 = v1().getType();
     auto type2 = v2().getType();
     if (::mlir::LLVM::getVectorElementType(type1) !=
             ::mlir::LLVM::getVectorElementType(type2))
       return emitOpError("expected matching LLVM IR Dialect element types");
     return success();
   }];
let description = [{
 
     // Define the global.
     llvm.mlir.global @const(42 : i32) : i32
     ```
   }];
 
   let builders = [
     OpBuilder<(ins "GlobalOp":$global,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       build($_builder, $_state,
             LLVM::LLVMPointerType::get(global.getType(), global.addr_space()),
             global.sym_name());
       $_state.addAttributes(attrs);
     }]>,
     OpBuilder<(ins "LLVMFuncOp":$func,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       build($_builder, $_state,
             LLVM::LLVMPointerType::get(func.getType()), func.getName());
       $_state.addAttributes(attrs);
     }]>
   ];
 
   let extraClassDeclaration = [{
def LLVM_GlobalOp : LLVM_Op<"mlir.global",
   let regions = (region AnyRegion:$initializer);
 
   let builders = [
     OpBuilder<(ins "Type":$type, "bool":$isConstant, "Linkage":$linkage,
       "StringRef":$name, "Attribute":$value,
       CArg<"uint64_t", "0">:$alignment,
       CArg<"unsigned", "0">:$addrSpace,
       CArg<"bool", "false">:$dsoLocal,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = [{
     /// Return the LLVM type of the global.
     Type getType() {
       return getGlobalType();
     }
     /// Return the initializer attribute if it exists, or a null attribute.
def LLVM_LLVMFuncOp : LLVM_Op<"func",
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, "Type":$type,
       CArg<"Linkage", "Linkage::External">:$linkage,
       CArg<"bool", "false">:$dsoLocal,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
+      CArg<"AttributeRange", "{}">:$attrs,
       CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)>
   ];
 
   let extraClassDeclaration = [{
     // Add an entry block to an empty function, and set up the block arguments
     // to match the signature of the function.
     Block *addEntryBlock();
 

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

[{
         shape.size(), ShapedType::kDynamicSize);
       build($_builder, $_state, shape, staticShape, elementType);
     }]>,
     OpBuilder<(ins "ArrayRef<int64_t>":$staticShape, "Type":$elementType),
     [{
       build($_builder, $_state, ValueRange{}, staticShape, elementType);
     }]>,
     OpBuilder<(ins "ArrayRef<OpFoldResult>":$sizes, "Type":$elementType,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let hasCanonicalizer = 1;
 }
 
 def Linalg_PadTensorOp : Linalg_Op<"pad_tensor",
     [AttrSizedOperandSegments, NoSideEffect,
      DeclareOpInterfaceMethods<ReifyRankedShapedTypeOpInterface>,
let extraClassDeclaration = [{
     }
   }];
 
   let builders = [
     // Build a PadTensorOp with mixed static and dynamic entries.
     OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$staticLow,
       "ArrayRef<int64_t>":$staticHigh, "ValueRange":$low, "ValueRange":$high,
       CArg<"bool", "false">:$nofold,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a PadTensorOp with all dynamic entries.
     OpBuilder<(ins "Value":$source, "ValueRange":$low, "ValueRange":$high,
       CArg<"bool", "false">:$nofold,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a PadTensorOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilder<(ins "Type":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$low, "ArrayRef<OpFoldResult>":$high,
       CArg<"bool", "false">:$nofold,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
   ];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
 def Linalg_RangeOp :
     Linalg_Op<"range", [NoSideEffect]>,

 
 class Linalg_ReshapeLikeOp<string mnemonic, list<OpTrait> traits = []> :
     Linalg_Op<mnemonic, !listconcat(traits, [NoSideEffect])> {
   let builders = [
     // Builders for a contracting reshape whose result type is computed from
     // `src` and `reassociation`.
     OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationMapsToIndices($_builder, reassociation);
       build($_builder, $_state, src, reassociationMaps, attrs);
     }]>,
 
     // Builders for a reshape whose result type is passed explicitly. This may
     // be either a contracting or expanding reshape.
     OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       build($_builder, $_state, resultType, src, attrs);
       $_state.addAttribute("reassociation",
                           getReassociationIndicesAttribute($_builder, reassociation));
     }]>,
     OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationMapsToIndices($_builder, reassociation);
       build($_builder, $_state, resultType, src, reassociationMaps, attrs);
     }]>
   ];
 
   code commonExtraClassDeclaration = [{

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

let arguments = (ins
     OptionalAttr<AffineMapAttr>:$inputPermutation,
     OptionalAttr<AffineMapAttr>:$outputPermutation);
   let regions = (region AnyRegion:$region);
 
   let builders = [
     OpBuilder<(ins "Value":$input, "Value":$output,
       CArg<"AffineMap", "AffineMap()">:$inputPermutation,
       CArg<"AffineMap", "AffineMap()">:$outputPermutation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
 
   let extraClassDeclaration = structuredOpsDecls # [{
     ValueRange inputs() { return getOperands().take_front(); }
     ValueRange outputs() { return getOperands().take_back(); }
 
     // Rank-polymorphic.
     //   filling_value -> O(ivs) with parallel iterators.
     ArrayAttr iterator_types() {
def GenericOp : LinalgStructuredBase_Op<"generic", [AttrSizedOperandSegments]> {
   let regions = (region AnyRegion:$region);
 
   let builders = [
     OpBuilder<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
       "ValueRange":$outputs, "ArrayRef<AffineMap>":$indexingMaps,
       "ArrayRef<StringRef>":$iteratorTypes, "StringRef":$doc,
       "StringRef":$libraryCall,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
+      CArg<"AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
       "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
       "StringRef":$doc, "StringRef":$libraryCall,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
+      CArg<"AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
       "ValueRange":$outputs, "ArrayRef<AffineMap>":$indexingMaps,
       "ArrayRef<StringRef>":$iteratorTypes,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
+      CArg<"AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
       "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
+      CArg<"AttributeRange", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = structuredOpsBaseDecls # [{
     SmallVector<StringRef, 8> linalgTraitAttrNames() {
       return SmallVector<StringRef, 8>{
         getDocAttrName(),
         getIndexingMapsAttrName(), getLibraryCallAttrName(),
         getIteratorTypesAttrName(),

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

def MemRef_ReinterpretCastOp:
   let parser = ?;
   let printer = ?;
 
   let builders = [
     // Build a ReinterpretCastOp with mixed static and dynamic entries.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "OpFoldResult":$offset, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a ReinterpretCastOp with static entries.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "int64_t":$offset, "ArrayRef<int64_t>":$sizes,
       "ArrayRef<int64_t>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a ReinterpretCastOp with dynamic entries.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "Value":$offset, "ValueRange":$sizes,
       "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     // The result of the op is always a ranked memref.
     MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
     Value getViewSource() { return source(); }
 
     /// Return the rank of the source ShapedType.
MemRef_Op<mnemonic, !listconcat(traits,
       [NoSideEffect, ViewLikeOpInterface])>,
     Arguments<(ins AnyStridedMemRef:$src, IndexListArrayAttr:$reassociation)>,
     Results<(outs AnyStridedMemRef:$result)>{
   let builders = [
     // Builders for a contracting reshape whose result type is computed from
     // `src` and `reassociation`.
     OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationMapsToIndices($_builder, reassociation);
       build($_builder, $_state, src, reassociationMaps, attrs);
     }]>,
 
     // Builders for a reshape whose result type is passed explicitly. This may
     // be either a contracting or expanding reshape.
     OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       build($_builder, $_state, resultType, src, attrs);
       $_state.addAttribute("reassociation",
                           getReassociationIndicesAttribute($_builder, reassociation));
     }]>,
     OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+      CArg<"AttributeRange", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationMapsToIndices($_builder, reassociation);
       build($_builder, $_state, resultType, src, reassociationMaps, attrs);
     }]>
   ];
 
   code commonExtraClassDeclaration = [{
let assemblyFormat = [{
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build a SubViewOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilder<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
       "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with mixed static and dynamic entries and inferred
     // result type.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with static entries and custom result type. If the
     // type passed is nullptr, it is inferred.
     OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$offsets,
       "ArrayRef<int64_t>":$sizes, "ArrayRef<int64_t>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with static entries and inferred result type.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "ArrayRef<int64_t>":$offsets, "ArrayRef<int64_t>":$sizes,
       "ArrayRef<int64_t>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with dynamic entries and custom result type. If the
     // type passed is nullptr, it is inferred.
     OpBuilder<(ins "Value":$source, "ValueRange":$offsets,
       "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a SubViewOp with dynamic entries and inferred result type.
     OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Returns the type of the base memref operand.
     MemRefType getSourceType() {
       return source().getType().cast<MemRefType>();
     }
 
let description = [{
 
     ```mlir
     %1 = memref.transpose %0 (i, j) -> (j, i) : memref<?x?xf32> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d1 * s0 + d0)>>
     ```
   }];
 
   let builders = [
     OpBuilder<(ins "Value":$in, "AffineMapAttr":$permutation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
 
   let extraClassDeclaration = [{
     static StringRef getPermutationAttrName() { return "permutation"; }
     ShapedType getShapedType() { return in().getType().cast<ShapedType>(); }
   }];
 
   let hasFolder = 1;
 }

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

let arguments = (ins Optional<AnyType>:$if_expr_var,
              Variadic<AnyType>:$copyin_vars,
              Variadic<AnyType>:$allocate_vars,
              Variadic<AnyType>:$allocators_vars,
              OptionalAttr<ProcBindKind>:$proc_bind_val);
 
   let regions = (region AnyRegion:$region);
 
   let builders = [
-    OpBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
+    OpBuilder<(ins CArg<"AttributeRange", "{}">:$attributes)>
   ];
   let parser = [{ return parseParallelOp(parser, result); }];
   let printer = [{ return printParallelOp(p, *this); }];
   let verifier = [{ return ::verifyParallelOp(*this); }];
 }
 
 def TerminatorOp : OpenMP_Op<"terminator", [Terminator]> {
   let summary = "terminator for OpenMP regions";
let arguments = (ins Variadic<IntLikeType>:$lowerBound,
              OptionalAttr<OrderKind>:$order_val,
              UnitAttr:$inclusive);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "ValueRange":$lowerBound, "ValueRange":$upperBound,
                "ValueRange":$step,
-               CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
+               CArg<"AttributeRange", "{}">:$attributes)>,
     OpBuilder<(ins "TypeRange":$resultTypes, "ValueRange":$lowerBound,
                "ValueRange":$upperBound, "ValueRange":$step,
                "ValueRange":$privateVars, "ValueRange":$firstprivateVars,
                "ValueRange":$lastprivate_vars, "ValueRange":$linear_vars,
                "ValueRange":$linear_step_vars, "ValueRange":$reduction_vars,
                "StringAttr":$schedule_val, "Value":$schedule_chunk_var,
                "IntegerAttr":$collapse_val, "UnitAttr":$nowait,
                "IntegerAttr":$ordered_val, "StringAttr":$order_val,
                "UnitAttr":$inclusive, CArg<"bool", "true">:$buildBody)>,
     OpBuilder<(ins "TypeRange":$resultTypes, "ValueRange":$operands,
-               CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
+               CArg<"AttributeRange", "{}">:$attributes)>
   ];
 
   let regions = (region AnyRegion:$region);
 
   let extraClassDeclaration = [{
     /// Returns the number of loops in the workshape loop nest.
     unsigned getNumLoops() { return lowerBound().size(); }
 

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

let arguments = (ins
     OptionalAttr<SPV_MemoryAccessAttr>:$memory_access,
     OptionalAttr<I32Attr>:$alignment
   );
 
   let results = (outs);
 
   let builders = [
     OpBuilder<(ins "Value":$ptr, "Value":$value,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$namedAttrs),
+      CArg<"AttributeRange", "{}">:$namedAttrs),
     [{
       $_state.addOperands(ptr);
       $_state.addOperands(value);
       $_state.addAttributes(namedAttrs);
     }]>
   ];
 }
 

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

def SPV_FuncOp : SPV_Op<"func", [
 
   let regions = (region AnyRegion:$body);
 
   let verifier = [{ return success(); }];
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, "FunctionType":$type,
       CArg<"spirv::FunctionControl", "spirv::FunctionControl::None">:$control,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+      CArg<"AttributeRange", "{}">:$attrs)>];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
   private:
     // This trait needs access to the hooks defined below.
OpBuilder<(ins "TypeAttr":$type,
                    "StringAttr":$sym_name,
                    CArg<"FlatSymbolRefAttr", "nullptr">:$initializer),
     [{
       $_state.addAttribute("type", type);
       $_state.addAttribute(sym_nameAttrName($_state.name), sym_name);
       if (initializer)
         $_state.addAttribute(initializerAttrName($_state.name), initializer);
     }]>,
-    OpBuilder<(ins "TypeAttr":$type, "ArrayRef<NamedAttribute>":$namedAttrs),
+    OpBuilder<(ins "TypeAttr":$type, "AttributeRange":$namedAttrs),
     [{
       $_state.addAttribute("type", type);
       $_state.addAttributes(namedAttrs);
     }]>,
     OpBuilder<(ins "Type":$type, "StringRef":$name,
       "unsigned":$descriptorSet, "unsigned":$binding)>,
     OpBuilder<(ins "Type":$type, "StringRef":$name,
       "spirv::BuiltIn":$builtin)>,

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

def Shape_ShapeEqOp : Shape_Op<"shape_eq",
   let builders = [
   OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
     [{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>,
   ];
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-    ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+    ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
       inferredReturnTypes.push_back(::mlir::IntegerType::get(context,
                                                              /*width=*/1));
       return success();
     };
   }];
 
   let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
def Shape_IsBroadcastableOp : Shape_Op<"is_broadcastable",
   let builders = [
   OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
     [{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>,
   ];
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-    ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+    ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
       inferredReturnTypes.push_back(::mlir::IntegerType::get(context,
                                                              /*width=*/1));
       return success();
     };
   }];
 
   let hasFolder = 1;
def Shape_CstrBroadcastableOp : Shape_Op<"cstr_broadcastable",
   OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
     [{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>,
   ];
 
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-    ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+    ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
       inferredReturnTypes.push_back(::mlir::shape::WitnessType::get(context));
       return success();
     };
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
def Shape_CstrEqOp : Shape_Op<"cstr_eq", [Commutative, InferTypeOpInterface]> {
   let results = (outs Shape_WitnessType:$result);
 
   let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
 
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-    ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+    ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
       inferredReturnTypes.push_back(::mlir::shape::WitnessType::get(context));
       return success();
     };
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

let assemblyFormat = [{
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build an ExtractSliceOp with mixed static and dynamic entries and
     // inferred result type.
     OpBuilder<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
       "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build an ExtractSliceOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilder<(ins "RankedTensorType":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build an ExtractSliceOp with dynamic entries and custom result type. If
     // the type passed is nullptr, it is inferred.
     OpBuilder<(ins "Value":$source, "ValueRange":$offsets,
       "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build an ExtractSliceOp with dynamic entries and inferred result type.
     OpBuilder<(ins "RankedTensorType":$resultType, "Value":$source,
       "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Returns the type of the base tensor operand.
     RankedTensorType getSourceType() {
       return source().getType().cast<RankedTensorType>();
     }
 
def Tensor_InsertSliceOp : BaseOpWithOffsetSizesAndStrides<
 
   let verifier = ?;
 
   let builders = [
     // Build a InsertSliceOp with mixed static and dynamic entries.
     OpBuilder<(ins "Value":$source, "Value":$dest,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+      CArg<"AttributeRange", "{}">:$attrs)>,
     // Build a InsertSliceOp with dynamic entries.
     OpBuilder<(ins "Value":$source, "Value":$dest,
       "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
+      CArg<"AttributeRange", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Returns the type of the base tensor operand.
     RankedTensorType getSourceType() {
       return source().getType().cast<RankedTensorType>();
     }
 

mlir/include/mlir/IR/AttributeRange.h

+#ifndef MLIR_IR_ATTRIBUTERANGE_H_
+#define MLIR_IR_ATTRIBUTERANGE_H_
+
+#include "mlir/IR/Attributes.h"
+#include "mlir/IR/Identifier.h"
+#include "llvm/ADT/STLExtras.h"
+
+namespace mlir {
+class DictionaryAttr;
+class NamedAttrList;
+namespace detail {
+class OpAttributeList;
+} // end namespace detail
+
+namespace impl {
+template <typename IteratorT>
+std::pair<IteratorT, bool>
+lookupAttributeSorted(IteratorT first, IteratorT last, StringRef name) {
+  auto length = std::distance(first, last);
+  using diff_t = decltype(length);
+
+  while (length > 0) {
+    diff_t half = length / 2;
+    IteratorT mid = first + half;
+    auto c = mid->first.strref().compare(name);
+    if (c < 0) {
+      first = mid;
+      ++first;
+      length = length - half - 1;
+    } else if (c > 0) {
+      length = half;
+    } else {
+      return {mid, true};
+    }
+  }
+  return {first, false};
+}
+
+template <typename IteratorT>
+std::pair<IteratorT, bool>
+lookupAttributeSorted(IteratorT first, IteratorT last, Identifier name) {
+  auto it = std::find_if(first, last, [name](const NamedAttribute &attr) {
+    return attr.first == name;
+  });
+  return {it, it != last};
+}
+
+namespace detail {
+const NamedAttribute *lookupAttributeBig(ArrayRef<NamedAttribute> attrs,
+                                         Identifier name);
+inline const NamedAttribute *
+lookupAttributeSmall(ArrayRef<NamedAttribute> attrs, Identifier name) {
+  for (auto *it = attrs.begin(), *e = attrs.end(); it != e; ++it) {
+    if (it->first == name)
+      return it;
+  }
+  return nullptr;
+}
+
+constexpr unsigned kSmallAttrList = 16;
+} // end namespace detail
+
+inline const NamedAttribute *
+lookupAttributeSpecial(ArrayRef<NamedAttribute> attrs, Identifier name) {
+  return attrs.size() >= detail::kSmallAttrList
+             ? detail::lookupAttributeBig(attrs, name)
+             : detail::lookupAttributeSmall(attrs, name);
+}
+
+inline const NamedAttribute *
+lookupAttributeSubrange(ArrayRef<NamedAttribute> attrs, Identifier name,
+                        unsigned left, unsigned right) {
+  for (auto *it = attrs.begin() + left, *e = attrs.end() - right; it != e;
+       ++it) {
+    if (it->first == name)
+      return it;
+  }
+  return nullptr;
+}
+
+template <typename IteratorT>
+std::pair<IteratorT, bool>
+lookupAttributeUnsorted(IteratorT first, IteratorT last, StringRef name) {
+  auto it = std::find_if(first, last, [name](const NamedAttribute &attr) {
+    return attr.first == name;
+  });
+  return {it, it != last};
+}
+
+template <typename IteratorT>
+std::pair<IteratorT, bool>
+lookupAttributeUnsorted(IteratorT first, IteratorT last, Identifier name) {
+  return lookupAttributeSorted(first, last, name);
+}
+} // end namespace impl
+
+class AttributeRange : public ArrayRef<NamedAttribute> {
+public:
+  using Base = ArrayRef<NamedAttribute>;
+
+  AttributeRange(ArrayRef<NamedAttribute> value = {}, bool sorted = false)
+      : Base(value), sorted(sorted) {}
+
+  /// Conversion to AttributeRange from other ranges and containers of
+  /// NamedAttribute.
+  AttributeRange(const SmallVectorImpl<NamedAttribute> &attrs,
+                 bool sorted = false)
+      : Base(attrs), sorted(sorted) {}
+  AttributeRange(const std::vector<NamedAttribute> &attrs, bool sorted = false)
+      : Base(attrs), sorted(sorted) {}
+  AttributeRange(const llvm::NoneType) : AttributeRange() {}
+  AttributeRange(std::initializer_list<NamedAttribute> attrs,
+                 bool sorted = false)
+      : Base(attrs), sorted(sorted) {}
+  AttributeRange(const NamedAttribute &attr) : Base(attr), sorted(false) {}
+
+  /// Conversion to sorted AttributeRange from ranges and containers that are
+  /// known to be sorted.
+  AttributeRange(const NamedAttrList &attrs);
+  AttributeRange(DictionaryAttr attrs);
+  AttributeRange(const detail::OpAttributeList &attrs);
+
+  bool isSorted() const { return sorted; }
+
+  SmallVector<NamedAttribute> toVector() const {
+    return llvm::to_vector<llvm::CalculateSmallVectorDefaultInlinedElements<
+        NamedAttribute>::value>(*this);
+  }
+
+private:
+  std::pair<iterator, bool> lookupAttribute(StringRef name) const {
+    return isSorted() ? impl::lookupAttributeSorted(begin(), end(), name)
+                      : impl::lookupAttributeUnsorted(begin(), end(), name);
+  }
+  const NamedAttribute *lookupAttrId(Identifier name) const {
+    return isSorted() && size() >= impl::detail::kSmallAttrList
+               ? impl::detail::lookupAttributeBig(*this, name)
+               : impl::detail::lookupAttributeSmall(*this, name);
+  }
+
+public:
+  /// Read-only dictionary-like operations.
+  Attribute get(StringRef name) const {
+    auto result = lookupAttribute(name);
+    return result.second ? result.first->second : Attribute();
+  }
+  Attribute get(Identifier name) const {
+    auto *ptr = lookupAttrId(name);
+    return ptr ? ptr->second : Attribute();
+  }
+  template <typename AttributeT, typename NameT>
+  AttributeT getAs(NameT name) const {
+    return get(name).template dyn_cast_or_null<AttributeT>();
+  }
+  Optional<NamedAttribute> getNamed(StringRef name) const {
+    auto result = lookupAttribute(name);
+    return result.second ? *result.first : Optional<NamedAttribute>();
+  }
+  Optional<NamedAttribute> getNamed(Identifier name) const {
+    auto *ptr = lookupAttrId(name);
+    return ptr ? *ptr : Optional<NamedAttribute>();
+  }
+
+  bool operator==(const AttributeRange &other) const { return equals(other); }
+
+private:
+  /// An attribute range created from a sorted NamedAttrList, DictionaryAttr,
+  /// or OpAttributeList is known to be sorted. Any operation that involves a
+  /// name lookup can be faster.
+  bool sorted = false;
+};
+
+inline llvm::hash_code hash_value(AttributeRange attrs) {
+  return llvm::hash_combine_range(attrs.begin(), attrs.end());
+}
+
+} // end namespace mlir
+
+#endif // MLIR_IR_ATTRIBUTERANGE_H_

mlir/include/mlir/IR/Builders.h

Ty getType(Args... args) {
     return Ty::get(context, args...);
   }
 
   // Attributes.
   NamedAttribute getNamedAttr(StringRef name, Attribute val);
 
   UnitAttr getUnitAttr();
   BoolAttr getBoolAttr(bool value);
-  DictionaryAttr getDictionaryAttr(ArrayRef<NamedAttribute> value);
+  DictionaryAttr getDictionaryAttr(AttributeRange value);
   IntegerAttr getIntegerAttr(Type type, int64_t value);
   IntegerAttr getIntegerAttr(Type type, const APInt &value);
   FloatAttr getFloatAttr(Type type, double value);
   FloatAttr getFloatAttr(Type type, const APFloat &value);
   StringAttr getStringAttr(const Twine &bytes);
   ArrayAttr getArrayAttr(ArrayRef<Attribute> value);
 
   // Returns a 0-valued attribute of the given `type`. This function only

mlir/include/mlir/IR/BuiltinAttributes.h

 //===- BuiltinAttributes.h - MLIR Builtin Attribute Classes -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_BUILTINATTRIBUTES_H
 #define MLIR_IR_BUILTINATTRIBUTES_H
 
+#include "mlir/IR/AttributeRange.h"
 #include "mlir/IR/BuiltinAttributeInterfaces.h"
 #include "mlir/IR/SubElementInterfaces.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/Sequence.h"
 #include <complex>
 
 namespace mlir {
 class AffineMap;

mlir/include/mlir/IR/BuiltinAttributes.td

def Builtin_DenseStringElementsAttr : Builtin_Attr<
   let genStorageClass = 0;
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // DictionaryAttr
 //===----------------------------------------------------------------------===//
 
+def AttrRangeParameter : AttrOrTypeParameter<"::mlir::AttributeRange", ""> {
+  let allocator = [{
+    $_dst = AttributeRange($_allocator.copyInto($_self), true);
+  }];
+}
+
 def Builtin_DictionaryAttr : Builtin_Attr<"Dictionary", [
     DeclareAttrInterfaceMethods<SubElementAttrInterface>
   ]> {
   let summary = "An dictionary of named Attribute values";
   let description = [{
     Syntax:
 
     ```
     dictionary-attribute ::= `{` (attribute-entry (`,` attribute-entry)*)? `}`
     ```
 
     A dictionary attribute is an attribute that represents a sorted collection of
     named attribute values. The elements are sorted by name, and each name must be
     unique within the collection.
 
     Examples:
 
     ```mlir
     {}
     {attr_name = "string attribute"}
     {int_attr = 10, "string attr name" = "string attribute"}
     ```
   }];
-  let parameters = (ins ArrayRefParameter<"NamedAttribute", "">:$value);
+  // TODO: DictionaryAttr should exist as an ArrayRef<NamedAttribute> and only
+  // be converted to AttributeRange as needed, but this cannot be done with ODS
+  // attributes.
+  let parameters = (ins AttrRangeParameter:$value);
   let builders = [
-    AttrBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "llvm::None">:$value)>
+    AttrBuilder<(ins CArg<"AttributeRange", "llvm::None">:$value)>
   ];
   let extraClassDeclaration = [{
-    using ValueType = ArrayRef<NamedAttribute>;
+    using ValueType = AttributeRange;
 
     /// Construct a dictionary with an array of values that is known to already
     /// be sorted by name and uniqued.
     static DictionaryAttr getWithSorted(MLIRContext *context,
-                                        ArrayRef<NamedAttribute> value);
+                                        AttributeRange value);
 
     /// Return the specified attribute if present, null otherwise.
     Attribute get(StringRef name) const;
     Attribute get(Identifier name) const;
 
     /// Return the specified named attribute if present, None otherwise.
     Optional<NamedAttribute> getNamed(StringRef name) const;
     Optional<NamedAttribute> getNamed(Identifier name) const;
 
     /// Support range iteration.
-    using iterator = llvm::ArrayRef<NamedAttribute>::iterator;
+    using iterator = AttributeRange::iterator;
     iterator begin() const;
     iterator end() const;
     bool empty() const { return size() == 0; }
     size_t size() const;
 
     /// Sorts the NamedAttributes in the array ordered by name as expected by
     /// getWithSorted and returns whether the values were sorted.
     /// Requires: uniquely named attributes.
-    static bool sort(ArrayRef<NamedAttribute> values,
+    static bool sort(AttributeRange values,
                      SmallVectorImpl<NamedAttribute> &storage);
 
     /// Sorts the NamedAttributes in the array ordered by name as expected by
     /// getWithSorted in place on an array and returns whether the values needed
     /// to be sorted.
     /// Requires: uniquely named attributes.
     static bool sortInPlace(SmallVectorImpl<NamedAttribute> &array);
 

mlir/include/mlir/IR/BuiltinOps.td

]> {
 
   let arguments = (ins SymbolNameAttr:$sym_name,
                        TypeAttr:$type,
                        OptionalAttr<StrAttr>:$sym_visibility);
   let regions = (region AnyRegion:$body);
 
   let builders = [OpBuilder<(ins
     "StringRef":$name, "FunctionType":$type,
-    CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
+    CArg<"AttributeRange", "{}">:$attrs,
     CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)
   >];
   let extraClassDeclaration = [{
     static FuncOp create(Location location, StringRef name, FunctionType type,
-                         ArrayRef<NamedAttribute> attrs = {});
+                         AttributeRange attrs = {});
     static FuncOp create(Location location, StringRef name, FunctionType type,
                          Operation::dialect_attr_range attrs);
     static FuncOp create(Location location, StringRef name, FunctionType type,
-                         ArrayRef<NamedAttribute> attrs,
+                         AttributeRange attrs,
                          ArrayRef<DictionaryAttr> argAttrs);
 
     /// Create a deep copy of this function and all of its blocks, remapping any
     /// operands that use values outside of the function using the map that is
     /// provided (leaving them alone if no entry is present). If the mapper
     /// contains entries for function arguments, these arguments are not
     /// included in the new function. Replaces references to cloned sub-values
     /// with the corresponding value that is copied, and adds those mappings to

mlir/include/mlir/IR/FunctionSupport.h

 /// size of `attrs` is expected to match the number of arguments/results of the
 /// given `op`.
 void setAllArgAttrDicts(Operation *op, ArrayRef<DictionaryAttr> attrs);
 void setAllArgAttrDicts(Operation *op, ArrayRef<Attribute> attrs);
 void setAllResultAttrDicts(Operation *op, ArrayRef<DictionaryAttr> attrs);
 void setAllResultAttrDicts(Operation *op, ArrayRef<Attribute> attrs);
 
 /// Return all of the attributes for the argument at 'index'.
-inline ArrayRef<NamedAttribute> getArgAttrs(Operation *op, unsigned index) {
+inline AttributeRange getArgAttrs(Operation *op, unsigned index) {
   auto argDict = getArgAttrDict(op, index);
   return argDict ? argDict.getValue() : llvm::None;
 }
 
 /// Return all of the attributes for the result at 'index'.
-inline ArrayRef<NamedAttribute> getResultAttrs(Operation *op, unsigned index) {
+inline AttributeRange getResultAttrs(Operation *op, unsigned index) {
   auto resultDict = getResultAttrDict(op, index);
   return resultDict ? resultDict.getValue() : llvm::None;
 }
 
 /// Insert the specified arguments and update the function type attribute.
 void insertFunctionArguments(Operation *op, ArrayRef<unsigned> argIndices,
                              TypeRange argTypes,
                              ArrayRef<DictionaryAttr> argAttrs,
public:
   /// FunctionLike operations allow for attaching attributes to each of the
   /// respective function arguments. These argument attributes are stored as
   /// DictionaryAttrs in the main operation attribute dictionary. The name of
   /// these entries is `arg` followed by the index of the argument. These
   /// argument attribute dictionaries are optional, and will generally only
   /// exist if they are non-empty.
 
   /// Return all of the attributes for the argument at 'index'.
-  ArrayRef<NamedAttribute> getArgAttrs(unsigned index) {
+  AttributeRange getArgAttrs(unsigned index) {
     return function_like_impl::getArgAttrs(this->getOperation(), index);
   }
 
   /// Return an ArrayAttr containing all argument attribute dictionaries of this
   /// function, or nullptr if no arguments have attributes.
   ArrayAttr getAllArgAttrs() {
     return this->getOperation()->template getAttrOfType<ArrayAttr>(
         function_like_impl::getArgDictAttrName());
AttrClass getArgAttrOfType(unsigned index, Identifier name) {
     return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
   }
   template <typename AttrClass>
   AttrClass getArgAttrOfType(unsigned index, StringRef name) {
     return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
   }
 
   /// Set the attributes held by the argument at 'index'.
-  void setArgAttrs(unsigned index, ArrayRef<NamedAttribute> attributes);
+  void setArgAttrs(unsigned index, AttributeRange attributes);
 
   /// Set the attributes held by the argument at 'index'. `attributes` may be
   /// null, in which case any existing argument attributes are removed.
   void setArgAttrs(unsigned index, DictionaryAttr attributes);
   void setAllArgAttrs(ArrayRef<DictionaryAttr> attributes) {
     assert(attributes.size() == getNumArguments());
     function_like_impl::setAllArgAttrDicts(this->getOperation(), attributes);
   }
public:
   /// FunctionLike operations allow for attaching attributes to each of the
   /// respective function results. These result attributes are stored as
   /// DictionaryAttrs in the main operation attribute dictionary. The name of
   /// these entries is `result` followed by the index of the result. These
   /// result attribute dictionaries are optional, and will generally only
   /// exist if they are non-empty.
 
   /// Return all of the attributes for the result at 'index'.
-  ArrayRef<NamedAttribute> getResultAttrs(unsigned index) {
+  AttributeRange getResultAttrs(unsigned index) {
     return function_like_impl::getResultAttrs(this->getOperation(), index);
   }
 
   /// Return an ArrayAttr containing all result attribute dictionaries of this
   /// function, or nullptr if no result have attributes.
   ArrayAttr getAllResultAttrs() {
     return this->getOperation()->template getAttrOfType<ArrayAttr>(
         function_like_impl::getResultDictAttrName());
AttrClass getResultAttrOfType(unsigned index, Identifier name) {
     return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
   }
   template <typename AttrClass>
   AttrClass getResultAttrOfType(unsigned index, StringRef name) {
     return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
   }
 
   /// Set the attributes held by the result at 'index'.
-  void setResultAttrs(unsigned index, ArrayRef<NamedAttribute> attributes);
+  void setResultAttrs(unsigned index, AttributeRange attributes);
 
   /// Set the attributes held by the result at 'index'. `attributes` may be
   /// null, in which case any existing argument attributes are removed.
   void setResultAttrs(unsigned index, DictionaryAttr attributes);
   void setAllResultAttrs(ArrayRef<DictionaryAttr> attributes) {
     assert(attributes.size() == getNumResults());
     function_like_impl::setAllResultAttrDicts(this->getOperation(), attributes);
   }

 }
 
 //===----------------------------------------------------------------------===//
 // Function Argument Attribute.
 //===----------------------------------------------------------------------===//
 
 /// Set the attributes held by the argument at 'index'.
 template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setArgAttrs(
-    unsigned index, ArrayRef<NamedAttribute> attributes) {
+void FunctionLike<ConcreteType>::setArgAttrs(unsigned index,
+                                             AttributeRange attributes) {
   assert(index < getNumArguments() && "invalid argument number");
   Operation *op = this->getOperation();
   return function_like_impl::detail::setArgResAttrDict(
       op, function_like_impl::getArgDictAttrName(), getNumArguments(), index,
       DictionaryAttr::get(op->getContext(), attributes));
 }
 
 template <typename ConcreteType>

 }
 
 //===----------------------------------------------------------------------===//
 // Function Result Attribute.
 //===----------------------------------------------------------------------===//
 
 /// Set the attributes held by the result at 'index'.
 template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setResultAttrs(
-    unsigned index, ArrayRef<NamedAttribute> attributes) {
+void FunctionLike<ConcreteType>::setResultAttrs(unsigned index,
+                                                AttributeRange attributes) {
   assert(index < getNumResults() && "invalid result number");
   Operation *op = this->getOperation();
   return function_like_impl::detail::setArgResAttrDict(
       op, function_like_impl::getResultDictAttrName(), getNumResults(), index,
       DictionaryAttr::get(op->getContext(), attributes));
 }
 
 template <typename ConcreteType>

mlir/include/mlir/IR/OpBase.td

class Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {
   //                   Attribute <attr0-name>, Attribute <attr1-name>, ...);
   // ```
   // * where the attributes follow the same declaration order as in the op.
   //
   // ```c++
   // static void build(OpBuilder &, OperationState &odsState,
   //                   TypeRange resultTypes,
   //                   ValueRange operands,
-  //                   ArrayRef<NamedAttribute> attributes);
+  //                   AttributeRange attributes);
   // ```
   list<OpBuilder> builders = ?;
 
   // Avoid generating default build functions.  Custom builders must be
   // provided.
   bit skipDefaultBuilders = 0;
 
   // Custom parser.

mlir/include/mlir/IR/OpImplementation.h

public:
   virtual void printNewline() = 0;
 
   /// Print a block argument in the usual format of:
   ///   %ssaName : type {attr1=42} loc("here")
   /// where location printing is controlled by the standard internal option.
   /// You may pass omitType=true to not print a type, and pass an empty
   /// attribute list if you don't care for attributes.
   virtual void printRegionArgument(BlockArgument arg,
-                                   ArrayRef<NamedAttribute> argAttrs = {},
+                                   AttributeRange argAttrs = {},
                                    bool omitType = false) = 0;
 
   /// Print implementations for various things an operation contains.
   virtual void printOperand(Value value) = 0;
   virtual void printOperand(Value value, raw_ostream &os) = 0;
 
   /// Print a comma separated list of operands.
   template <typename ContainerType>
public:
   /// Print the successor and its operands.
   virtual void printSuccessorAndUseList(Block *successor,
                                         ValueRange succOperands) = 0;
 
   /// If the specified operation has attributes, print out an attribute
   /// dictionary with their values.  elidedAttrs allows the client to ignore
   /// specific well known attributes, commonly used if the attribute value is
   /// printed some other way (like as a fixed operand).
-  virtual void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+  virtual void printOptionalAttrDict(AttributeRange attrs,
                                      ArrayRef<StringRef> elidedAttrs = {}) = 0;
 
   /// If the specified operation has attributes, print out an attribute
   /// dictionary prefixed with 'attributes'.
   virtual void
-  printOptionalAttrDictWithKeyword(ArrayRef<NamedAttribute> attrs,
+  printOptionalAttrDictWithKeyword(AttributeRange attrs,
                                    ArrayRef<StringRef> elidedAttrs = {}) = 0;
 
   /// Print the entire operation with the default generic assembly form.
   /// If `printOpName` is true, then the operation name is printed (the default)
   /// otherwise it is omitted and the print will start with the operand list.
   virtual void printGenericOp(Operation *op, bool printOpName = true) = 0;
 
   /// Prints a region.
public:
   // Attribute/Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Invoke the `getChecked` method of the given Attribute or Type class, using
   /// the provided location to emit errors in the case of failure. Note that
   /// unlike `OpBuilder::getType`, this method does not implicitly insert a
   /// context parameter.
   template <typename T, typename... ParamsT>
-  T getChecked(llvm::SMLoc loc, ParamsT &&... params) {
+  T getChecked(llvm::SMLoc loc, ParamsT &&...params) {
     return T::getChecked([&] { return emitError(loc); },
                          std::forward<ParamsT>(params)...);
   }
   /// A variant of `getChecked` that uses the result of `getNameLoc` to emit
   /// errors.
   template <typename T, typename... ParamsT>
-  T getChecked(ParamsT &&... params) {
+  T getChecked(ParamsT &&...params) {
     return T::getChecked([&] { return emitError(getNameLoc()); },
                          std::forward<ParamsT>(params)...);
   }
 
   //===--------------------------------------------------------------------===//
   // Attribute Parsing
   //===--------------------------------------------------------------------===//
 

mlir/include/mlir/IR/Operation.h

 namespace mlir {
 /// Operation is a basic unit of execution within MLIR. Operations can
 /// be nested within `Region`s held by other operations effectively forming a
 /// tree. Child operations are organized into operation blocks represented by a
 /// 'Block' class.
 class alignas(8) Operation final
     : public llvm::ilist_node_with_parent<Operation, Block>,
       private llvm::TrailingObjects<Operation, BlockOperand, Region,
-                                    detail::OperandStorage> {
+                                    NamedAttribute, detail::OperandStorage> {
 public:
   /// Create a new Operation with the specific fields.
   static Operation *create(Location location, OperationName name,
                            TypeRange resultTypes, ValueRange operands,
-                           ArrayRef<NamedAttribute> attributes,
-                           BlockRange successors, unsigned numRegions);
-
-  /// Overload of create that takes an existing DictionaryAttr to avoid
-  /// unnecessarily uniquing a list of attributes.
-  static Operation *create(Location location, OperationName name,
-                           TypeRange resultTypes, ValueRange operands,
-                           DictionaryAttr attributes, BlockRange successors,
+                           AttributeRange attributes, BlockRange successors,
                            unsigned numRegions);
 
   /// Create a new Operation from the fields stored in `state`.
   static Operation *create(const OperationState &state);
 
   /// Create a new Operation with the specific fields.
   static Operation *create(Location location, OperationName name,
                            TypeRange resultTypes, ValueRange operands,
-                           DictionaryAttr attributes,
+                           AttributeRange attributes,
                            BlockRange successors = {},
                            RegionRange regions = {});
 
   /// The name of an operation is the key identifier for it.
   OperationName getName() { return name; }
 
   /// If this operation has a registered operation description, return it.
   /// Otherwise return null.
public:
   // Attributes
   //===--------------------------------------------------------------------===//
 
   // Operations may optionally carry a list of attributes that associate
   // constants to names.  Attributes may be dynamically added and removed over
   // the lifetime of an operation.
 
   /// Return all of the attributes on this operation.
-  ArrayRef<NamedAttribute> getAttrs() { return attrs.getValue(); }
+  AttributeRange getAttrs() { return attrs; }
+  AttributeRange::iterator attr_begin() { return getAttrs().begin(); }
+  AttributeRange::iterator attr_end() { return getAttrs().end(); }
 
   /// Return all of the attributes on this operation as a DictionaryAttr.
-  DictionaryAttr getAttrDictionary() { return attrs; }
+  DictionaryAttr getAttrDictionary() {
+    return attrs.convertToDictionary(getContext());
+  }
 
   /// Set the attribute dictionary on this operation.
-  void setAttrs(DictionaryAttr newAttrs) {
-    assert(newAttrs && "expected valid attribute dictionary");
-    attrs = newAttrs;
-  }
-  void setAttrs(ArrayRef<NamedAttribute> newAttrs) {
-    setAttrs(DictionaryAttr::get(getContext(), newAttrs));
-  }
+  void setAttrs(AttributeRange newAttrs) { attrs.assign(newAttrs); }
 
   /// Return the specified attribute if present, null otherwise.
   Attribute getAttr(Identifier name) { return attrs.get(name); }
   Attribute getAttr(StringRef name) { return attrs.get(name); }
 
+  Optional<NamedAttribute> getNamedAttr(Identifier name) {
+    return attrs.getNamed(name);
+  }
+  Optional<NamedAttribute> getNamedAttr(StringRef name) {
+    return attrs.getNamed(name);
+  }
+
   template <typename AttrClass> AttrClass getAttrOfType(Identifier name) {
     return getAttr(name).dyn_cast_or_null<AttrClass>();
   }
   template <typename AttrClass> AttrClass getAttrOfType(StringRef name) {
     return getAttr(name).dyn_cast_or_null<AttrClass>();
   }
 
   /// Return true if the operation has an attribute with the provided name,
   /// false otherwise.
-  bool hasAttr(Identifier name) { return static_cast<bool>(getAttr(name)); }
-  bool hasAttr(StringRef name) { return static_cast<bool>(getAttr(name)); }
+  bool hasAttr(Identifier name) { return attrs.has(name); }
+  bool hasAttr(StringRef name) { return attrs.has(name); }
   template <typename AttrClass, typename NameT>
   bool hasAttrOfType(NameT &&name) {
     return static_cast<bool>(
         getAttrOfType<AttrClass>(std::forward<NameT>(name)));
   }
 
   /// If the an attribute exists with the specified name, change it to the new
   /// value. Otherwise, add a new attribute with the specified name/value.
-  void setAttr(Identifier name, Attribute value) {
-    NamedAttrList attributes(attrs);
-    if (attributes.set(name, value) != value)
-      attrs = attributes.getDictionary(getContext());
-  }
-  void setAttr(StringRef name, Attribute value) {
-    setAttr(Identifier::get(name, getContext()), value);
-  }
+  void setAttr(Identifier name, Attribute value) { attrs.set(name, value); }
+  void setAttr(StringRef name, Attribute value) { attrs.set(name, value); }
 
   /// Remove the attribute with the specified name if it exists. Return the
   /// attribute that was erased, or nullptr if there was no attribute with such
   /// name.
-  Attribute removeAttr(Identifier name) {
-    NamedAttrList attributes(attrs);
-    Attribute removedAttr = attributes.erase(name);
-    if (removedAttr)
-      attrs = attributes.getDictionary(getContext());
-    return removedAttr;
-  }
-  Attribute removeAttr(StringRef name) {
-    return removeAttr(Identifier::get(name, getContext()));
-  }
+  Attribute removeAttr(Identifier name) { return attrs.erase(name); }
+  Attribute removeAttr(StringRef name) { return attrs.erase(name); }
 
   /// A utility iterator that filters out non-dialect attributes.
   class dialect_attr_iterator
-      : public llvm::filter_iterator<ArrayRef<NamedAttribute>::iterator,
+      : public llvm::filter_iterator<AttributeRange::iterator,
                                      bool (*)(NamedAttribute)> {
     static bool filter(NamedAttribute attr) {
       // Dialect attributes are prefixed by the dialect name, like operations.
       return attr.first.strref().count('.');
     }
 
-    explicit dialect_attr_iterator(ArrayRef<NamedAttribute>::iterator it,
-                                   ArrayRef<NamedAttribute>::iterator end)
-        : llvm::filter_iterator<ArrayRef<NamedAttribute>::iterator,
+    explicit dialect_attr_iterator(AttributeRange::iterator it,
+                                   AttributeRange::iterator end)
+        : llvm::filter_iterator<AttributeRange::iterator,
                                 bool (*)(NamedAttribute)>(it, end, &filter) {}
 
     // Allow access to the constructor.
     friend Operation;
   };
   using dialect_attr_range = iterator_range<dialect_attr_iterator>;
 
   /// Return a range corresponding to the dialect attributes for this operation.
public:
   /// Set the dialect attributes for this operation, and preserve all dependent.
   template <typename DialectAttrT>
   void setDialectAttrs(DialectAttrT &&dialectAttrs) {
     NamedAttrList attrs;
     attrs.append(std::begin(dialectAttrs), std::end(dialectAttrs));
     for (auto attr : getAttrs())
       if (!attr.first.strref().contains('.'))
         attrs.push_back(attr);
-    setAttrs(attrs.getDictionary(getContext()));
+    setAttrs(attrs);
   }
 
+  /// Get a reference to the underlying attribute storage.
+  detail::OpAttributeList &getOpAttributes() { return attrs; }
+
   //===--------------------------------------------------------------------===//
   // Blocks
   //===--------------------------------------------------------------------===//
 
   /// Returns the number of regions held by this operation.
   unsigned getNumRegions() { return numRegions; }
 
   /// Returns the regions held by this operation.
private:
   void updateOrderIfNecessary();
 
   /// Returns true if this operation has a valid order.
   bool hasValidOrder() { return orderIndex != kInvalidOrderIdx; }
 
 private:
   Operation(Location location, OperationName name, unsigned numResults,
             unsigned numSuccessors, unsigned numRegions,
-            DictionaryAttr attributes, bool hasOperandStorage);
+            unsigned numInlineAttributes, AttributeRange attributes,
+            bool hasOperandStorage);
 
   // Operations are deleted through the destroy() member because they are
   // allocated with malloc.
   ~Operation();
 
   /// Returns the additional size necessary for allocating the given objects
   /// before an Operation in-memory.
   static size_t prefixAllocSize(unsigned numOutOfLineResults,
private:
   /// either inline or out-of-line.
   detail::OpResultImpl *getOpResultImpl(unsigned resultNumber) {
     unsigned maxInlineResults = detail::OpResultImpl::getMaxInlineResults();
     if (resultNumber < maxInlineResults)
       return getInlineOpResult(resultNumber);
     return getOutOfLineOpResult(resultNumber - maxInlineResults);
   }
 
+  /// Get the inline storage allocated for attributes.
+  MutableArrayRef<NamedAttribute> getInlineAttrStorage() {
+    return {getTrailingObjects<NamedAttribute>(), numInlineAttrs};
+  }
+
   /// Provide a 'getParent' method for ilist_node_with_parent methods.
   /// We mark it as a const function because ilist_node_with_parent specifically
   /// requires a 'getParent() const' method. Once ilist_node removes this
   /// constraint, we should drop the const to fit the rest of the MLIR const
   /// model.
   Block *getParent() const { return block; }
 
   /// The operation block that contains this operation.
   Block *block = nullptr;
 
   /// This holds information about the source location the operation was defined
   /// or derived from.
   Location location;
 
   /// Relative order of this operation in its parent block. Used for
   /// O(1) local dominance checks between operations.
   mutable unsigned orderIndex = 0;
 
   const unsigned numResults;
   const unsigned numSuccs;
-  const unsigned numRegions : 31;
+  const unsigned numRegions : 25;
+  static constexpr unsigned kMaxInlineAttrs = 63;
+  const unsigned numInlineAttrs : 6;
 
   /// This bit signals whether this operation has an operand storage or not. The
   /// operand storage may be elided for operations that are known to never have
   /// operands.
   bool hasOperandStorage : 1;
 
   /// This holds the name of the operation.
   OperationName name;
 
   /// This holds general named attributes for the operation.
-  DictionaryAttr attrs;
+  detail::OpAttributeList attrs;
 
   // allow ilist_traits access to 'block' field.
   friend struct llvm::ilist_traits<Operation>;
 
   // allow block to access the 'orderIndex' field.
   friend class Block;
 
   // allow value to access the 'ResultStorage' methods.
   friend class Value;
 
   // allow ilist_node_with_parent to access the 'getParent' method.
   friend class llvm::ilist_node_with_parent<Operation, Block>;
 
   // This stuff is used by the TrailingObjects template.
-  friend llvm::TrailingObjects<Operation, BlockOperand, Region,
+  friend llvm::TrailingObjects<Operation, BlockOperand, Region, NamedAttribute,
                                detail::OperandStorage>;
   size_t numTrailingObjects(OverloadToken<BlockOperand>) const {
     return numSuccs;
   }
   size_t numTrailingObjects(OverloadToken<Region>) const { return numRegions; }
+  size_t numTrailingObjects(OverloadToken<NamedAttribute>) const {
+    return numInlineAttrs;
+  }
 };
 
 inline raw_ostream &operator<<(raw_ostream &os, const Operation &op) {
   const_cast<Operation &>(op).print(os, OpPrintingFlags().useLocalScope());
   return os;
 }
 
 } // end namespace mlir

mlir/include/mlir/IR/OperationSupport.h

 //===- OperationSupport.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a number of support types that Operation and related
 // classes build on top of.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_OPERATION_SUPPORT_H
 #define MLIR_IR_OPERATION_SUPPORT_H
 
+#include "mlir/IR/AttributeRange.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BlockSupport.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Support/InterfaceSupport.h"

 class NamedAttrList {
 public:
   using const_iterator = SmallVectorImpl<NamedAttribute>::const_iterator;
   using const_reference = const NamedAttribute &;
   using reference = NamedAttribute &;
   using size_type = size_t;
 
   NamedAttrList() : dictionarySorted({}, true) {}
-  NamedAttrList(ArrayRef<NamedAttribute> attributes);
+  NamedAttrList(AttributeRange attributes);
   NamedAttrList(DictionaryAttr attributes);
   NamedAttrList(const_iterator in_start, const_iterator in_end);
+  template <typename IteratorT>
+  NamedAttrList(IteratorT in_start, IteratorT in_end) {
+    assign(in_start, in_end);
+  }
 
   bool operator!=(const NamedAttrList &other) const {
     return !(*this == other);
   }
   bool operator==(const NamedAttrList &other) const {
     return attrs == other.attrs;
   }
 
void append(IteratorT in_start, IteratorT in_end) {
     // end of current list.
     dictionarySorted.setPointerAndInt(nullptr, false);
     attrs.append(in_start, in_end);
   }
 
   /// Replaces the attributes with new list of attributes.
   void assign(const_iterator in_start, const_iterator in_end);
 
-  /// Replaces the attributes with new list of attributes.
-  void assign(ArrayRef<NamedAttribute> range) {
-    assign(range.begin(), range.end());
+  template <typename IteratorT>
+  void assign(IteratorT in_start, IteratorT in_end) {
+    dictionarySorted.setPointerAndInt(nullptr, false);
+    attrs.assign(in_start, in_end);
   }
 
+  /// Replaces the attributes with new list of attributes.
+  void assign(AttributeRange range) { assign(range.begin(), range.end()); }
+
   bool empty() const { return attrs.empty(); }
 
   void reserve(size_type N) { attrs.reserve(N); }
 
   /// Add an attribute with the specified name.
   void push_back(NamedAttribute newAttribute);
 
   /// Pop last element from list.
   void pop_back() { attrs.pop_back(); }
 
   /// Returns an entry with a duplicate name the list, if it exists, else
   /// returns llvm::None.
   Optional<NamedAttribute> findDuplicate() const;
 
   /// Return a dictionary attribute for the underlying dictionary. This will
   /// return an empty dictionary attribute if empty rather than null.
   DictionaryAttr getDictionary(MLIRContext *context) const;
 
   /// Return all of the attributes on this operation.
-  ArrayRef<NamedAttribute> getAttrs() const;
+  AttributeRange getAttrs() const;
 
   /// Return the specified attribute if present, null otherwise.
   Attribute get(Identifier name) const;
   Attribute get(StringRef name) const;
 
   /// Return the specified named attribute if present, None otherwise.
   Optional<NamedAttribute> getNamed(StringRef name) const;
   Optional<NamedAttribute> getNamed(Identifier name) const;
public:
   Attribute erase(StringRef name);
 
   const_iterator begin() const { return attrs.begin(); }
   const_iterator end() const { return attrs.end(); }
 
   NamedAttrList &operator=(const SmallVectorImpl<NamedAttribute> &rhs);
   operator ArrayRef<NamedAttribute>() const;
 
-private:
   /// Return whether the attributes are sorted.
   bool isSorted() const { return dictionarySorted.getInt(); }
 
+private:
   /// Erase the attribute at the given iterator position.
   Attribute eraseImpl(SmallVectorImpl<NamedAttribute>::iterator it);
 
   // These are marked mutable as they may be modified (e.g., sorted)
   mutable SmallVector<NamedAttribute, 4> attrs;
   // Pair with cached DictionaryAttr and status of whether attrs is sorted.
   // Note: just because sorted does not mean a DictionaryAttr has been created
   // but the case where there is a DictionaryAttr but attrs isn't sorted should
struct OperationState {
   SmallVector<std::unique_ptr<Region>, 1> regions;
 
 public:
   OperationState(Location location, StringRef name);
 
   OperationState(Location location, OperationName name);
 
   OperationState(Location location, StringRef name, ValueRange operands,
-                 TypeRange types, ArrayRef<NamedAttribute> attributes,
+                 TypeRange types, AttributeRange attributes,
                  BlockRange successors = {},
                  MutableArrayRef<std::unique_ptr<Region>> regions = {});
 
   void addOperands(ValueRange newOperands);
 
   void addTypes(ArrayRef<Type> newTypes) {
     types.append(newTypes.begin(), newTypes.end());
   }
public:
   }
 
   /// Add an attribute with the specified name.
   void addAttribute(Identifier name, Attribute attr) {
     attributes.append(name, attr);
   }
 
   /// Add an array of named attributes.
-  void addAttributes(ArrayRef<NamedAttribute> newAttributes) {
+  void addAttributes(AttributeRange newAttributes) {
     attributes.append(newAttributes);
   }
 
   void addSuccessors(Block *successor) { successors.push_back(successor); }
   void addSuccessors(BlockRange newSuccessors);
 
   /// Create a region that should be attached to the operation.  These regions
   /// can be filled in immediately without waiting for Operation to be
public:
   /// Operation.
   void addRegions(MutableArrayRef<std::unique_ptr<Region>> regions);
 
   /// Get the context held by this operation state.
   MLIRContext *getContext() const { return location->getContext(); }
 };
 
 //===----------------------------------------------------------------------===//
+// OpAttributeList
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class AttributeAllocator : public std::allocator<NamedAttribute> {
+public:
+  using size_type = unsigned;
+  using difference_type = int;
+};
+
+class OpAttributeStorage {
+public:
+  using size_type = unsigned;
+  using difference_type = int;
+  using iterator = NamedAttribute *;
+  using const_iterator = const NamedAttribute *;
+
+private:
+  /// The provided storage is inline with the operation, and for "small" lists,
+  /// will contain exactly enough space to contain the attributes [first, last).
+  /// For "large" lists, no inline storage is provided.
+  OpAttributeStorage(MutableArrayRef<NamedAttribute> initialStorage,
+                     const_iterator first, const_iterator last)
+      : ptr(initialStorage.data()), size(0), capacity(initialStorage.size()),
+        isHeap(false) {
+    assign(first, last);
+  }
+  /// Free the memory if it came from the heap.
+  ~OpAttributeStorage() {
+    if (isHeap)
+      free(ptr);
+  }
+
+  operator ArrayRef<NamedAttribute>() const { return {ptr, size}; }
+
+  iterator begin() { return ptr; }
+  iterator end() { return begin() + size; }
+  const_iterator begin() const { return ptr; }
+  const_iterator end() const { return begin() + size; }
+
+  void erase(iterator it) {
+    size_type newSize = size - 1;
+    for (auto *e = end() - 1; it != e; ++it)
+      *it = *(it + 1);
+    size = newSize;
+  }
+
+  void insert(iterator it, NamedAttribute value) {
+    size_type newSize = size + 1;
+    if (newSize > capacity) {
+      capacity = 2u * (capacity + 1u);
+      size_type memSize = capacity * sizeof(NamedAttribute);
+      size_type index = it - ptr;
+      if (isHeap) {
+        ptr = reinterpret_cast<NamedAttribute *>(realloc(ptr, memSize));
+        it = ptr + index;
+        for (auto *e = end(); e != it; --e)
+          *e = *(e - 1);
+        *it = value;
+      } else {
+        auto *newPtr = reinterpret_cast<NamedAttribute *>(malloc(memSize));
+        pod_copy(ptr, newPtr, index);
+        *(it = newPtr + index) = value;
+        pod_copy(ptr + index, it + 1, size - index);
+        ptr = newPtr;
+      }
+    } else {
+      for (auto *e = end(); e != it; --e)
+        *e = *(e - 1);
+      *it = value;
+    }
+    size = newSize;
+  }
+
+  void assign(const_iterator first, const_iterator last) {
+    size_type newSize = last - first;
+    if (newSize > capacity) {
+      capacity = std::max(newSize, 2u * (capacity + 1u));
+      size_t memSize = capacity * sizeof(NamedAttribute);
+      ptr = reinterpret_cast<NamedAttribute *>(isHeap ? realloc(ptr, memSize)
+                                                      : malloc(memSize));
+    }
+    pod_copy(first, ptr, newSize);
+    size = newSize;
+  }
+
+  static void pod_copy(const_iterator first, iterator dest, size_type num) {
+    memcpy(dest, first, num * sizeof(NamedAttribute));
+  }
+
+  /// Store whether the pointer is from dynamic storage.
+  NamedAttribute *ptr;
+  size_type size;
+  size_type capacity;
+  bool isHeap;
+
+  friend class OpAttributeList;
+};
+
+class OpAttributeList {
+  using Storage = std::vector<NamedAttribute>;
+  // using Storage = SmallVector<NamedAttribute, 4>;
+  // using Storage = OpAttributeStorage;
+  // using Storage = std::vector<NamedAttribute, AttributeAllocator>;
+
+public:
+  using iterator = Storage::iterator;
+  using const_iterator = Storage::const_iterator;
+
+  OpAttributeList(MutableArrayRef<NamedAttribute> initialStorage,
+                  AttributeRange attributes);
+
+  Attribute get(Identifier name) const {
+    auto *ptr = impl::lookupAttributeSpecial(attrs, name);
+    return ptr ? ptr->second : Attribute();
+  }
+  Attribute get(StringRef name) const {
+    auto it = lookupAttribute(name);
+    return it.second ? it.first->second : Attribute();
+  }
+  Attribute get(Identifier name, unsigned left, unsigned right) const {
+    auto *ptr = impl::lookupAttributeSubrange(attrs, name, left, right);
+    // if (LLVM_UNLIKELY(!ptr))
+    //   ptr = impl::lookupAttributeSpecial(attrs, name);
+    return ptr ? ptr->second : Attribute();
+  }
+
+  Optional<NamedAttribute> getNamed(Identifier name) const {
+    auto *ptr = impl::lookupAttributeSpecial(attrs, name);
+    return ptr ? *ptr : Optional<NamedAttribute>();
+  }
+  Optional<NamedAttribute> getNamed(StringRef name) const {
+    auto it = lookupAttribute(name);
+    return it.second ? *it.first : Optional<NamedAttribute>();
+  }
+  Optional<NamedAttribute> getNamed(Identifier name, unsigned left,
+                                    unsigned right) const {
+    auto *ptr = impl::lookupAttributeSubrange(attrs, name, left, right);
+    return ptr ? *ptr : Optional<NamedAttribute>();
+  }
+
+  bool has(Identifier name) const {
+    return impl::lookupAttributeSpecial(attrs, name);
+  }
+  bool has(StringRef name) const { return lookupAttribute(name).second; }
+  bool has(Identifier name, unsigned left, unsigned right) const {
+    return impl::lookupAttributeSubrange(attrs, name, left, right);
+  }
+
+  template <typename NameT>
+  Attribute erase(NameT name, unsigned left = 0, unsigned right = 0) {
+    auto it = lookupAttribute(name, left, right);
+    if (!it.second)
+      return Attribute();
+    auto value = it.first->second;
+    attrs.erase(it.first);
+    return value;
+  }
+
+  void set(StringRef name, Attribute value);
+  void set(Identifier name, Attribute value, unsigned left = 0,
+           unsigned right = 0);
+
+  /// Add an attribute when it is known that the attribute is more likely to not
+  /// already be in the list. This method goes straight to string lookup, which
+  /// is faster than set(Identifier, Attribute) when adding a new attribute.
+  void addOrSet(Identifier name, Attribute value);
+  /// Set an attribute when it is known that the attribute is more like to
+  /// already be in the list. This method skips the string lookup, which *may*
+  /// be faster than set(StringRef, Attribute) when overwriting an attribute.
+  void setOrAdd(StringRef name, Attribute value);
+
+  void definitelySet(Identifier name, Attribute value, unsigned left,
+                     unsigned right);
+  template <
+      typename MaterializeValueFn,
+      typename AttributeT = decltype(std::declval<MaterializeValueFn>()())>
+  AttributeT getOrSet(Identifier name, MaterializeValueFn &&materialize,
+                      unsigned left, unsigned right) {
+    auto it = lookupAttribute(name.strref(), left, right);
+    if (it.second)
+      return it.first->second.cast<AttributeT>();
+    AttributeT value = materialize();
+    // attrs.insert(it.first, {name, value});
+    return value;
+  }
+
+  void assign(AttributeRange attributes);
+
+  /// Conversions to other attribute ranges and containers.
+  operator ArrayRef<NamedAttribute>() const { return attrs; }
+  DictionaryAttr convertToDictionary(MLIRContext *context) const;
+
+public:
+  // Search a subset of the list when it is known that an attribute will have
+  // `left` attributes to its left and `right` attributes to its right based on
+  // sortedness.
+  template <typename NameT>
+  std::pair<iterator, bool> lookupAttribute(NameT name, unsigned left = 0,
+                                            unsigned right = 0) {
+    return impl::lookupAttributeSorted(attrs.begin() + left,
+                                       attrs.end() - right, name);
+  }
+  template <typename NameT>
+  std::pair<const_iterator, bool> lookupAttribute(NameT name, unsigned left = 0,
+                                                  unsigned right = 0) const {
+    return impl::lookupAttributeSorted(attrs.begin() + left,
+                                       attrs.end() - right, name);
+  }
+
+  /// The internal storage of attributes inside an operation.
+  Storage attrs;
+};
+} // end namespace detail
+
+//===----------------------------------------------------------------------===//
 // OperandStorage
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// This class contains the information for a trailing operand storage.
 struct TrailingOperandStorage final
     : public llvm::TrailingObjects<TrailingOperandStorage, OpOperand> {
 #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && (BYTE_ORDER == BIG_ENDIAN)

mlir/include/mlir/Interfaces/InferTypeOpInterface.h

 // Helper function to infer return tensor returns types given element and
 // shape inference function.
 //
 // TODO: Consider generating typedefs for trait member functions if this usage
 // becomes more common.
 LogicalResult inferReturnTensorTypes(
     function_ref<LogicalResult(
         MLIRContext *, Optional<Location> location, ValueShapeRange operands,
-        DictionaryAttr attributes, RegionRange regions,
+        AttributeRange attributes, RegionRange regions,
         SmallVectorImpl<ShapedTypeComponents> &retComponents)>
         componentTypeFn,
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes);
 
 /// Verifies that the inferred result types match the actual result types for
 /// the op. Precondition: op implements InferTypeOpInterface.
 LogicalResult verifyInferredResultTypes(Operation *op);
 } // namespace detail
 
 namespace OpTrait {

 ///   these always populates all element types and shapes or fails, but this\
 ///   trait is currently only used where the interfaces are, so keep it
 ///   restricted for now).
 template <typename ConcreteType>
 class InferTensorType : public TraitBase<ConcreteType, InferTensorType> {
 public:
   static LogicalResult
   inferReturnTypes(MLIRContext *context, Optional<Location> location,
-                   ValueRange operands, DictionaryAttr attributes,
+                   ValueRange operands, AttributeRange attributes,
                    RegionRange regions,
                    SmallVectorImpl<Type> &inferredReturnTypes) {
     static_assert(
         ConcreteType::template hasTrait<InferShapedTypeOpInterface::Trait>(),
         "requires InferShapedTypeOpInterface to ensure succesful invocation");
     static_assert(
         ConcreteType::template hasTrait<InferTypeOpInterface::Trait>(),
         "requires InferTypeOpInterface to ensure succesful invocation");

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

StaticInterfaceMethod<
       called with valid arguments, e.g., operands are verified, or it may result
       in an undefined behavior.
       }],
       /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"inferReturnTypes",
       /*args=*/(ins "::mlir::MLIRContext *":$context,
                     "::llvm::Optional<::mlir::Location>":$location,
                     "::mlir::ValueRange":$operands,
-                    "::mlir::DictionaryAttr":$attributes,
+                    "::mlir::AttributeRange":$attributes,
                     "::mlir::RegionRange":$regions,
                     "::llvm::SmallVectorImpl<::mlir::Type>&":$inferredReturnTypes)
     >,
     StaticInterfaceMethod<
       /*desc=*/"Returns whether two array of types are compatible result types"
                " for an op.",
       /*retTy=*/"bool",
       /*methodName=*/"isCompatibleReturnTypes",
StaticInterfaceMethod<
       may be returned by this function while returning success. E.g., partial
       population of components is not error condition.
       }],
       /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"inferReturnTypeComponents",
       /*args=*/(ins "::mlir::MLIRContext*":$context,
                     "::mlir::Optional<::mlir::Location>":$location,
                     "::mlir::ValueShapeRange":$operands,
-                    "::mlir::DictionaryAttr":$attributes,
+                    "::mlir::AttributeRange":$attributes,
                     "::mlir::RegionRange":$regions,
                     "::mlir::SmallVectorImpl<::mlir::ShapedTypeComponents>&":
                       $inferredReturnShapes),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{ return ::mlir::failure(); }]
     >,
     InterfaceMethod<
       /*desc=*/[{Reify the shape computation for the operation.

mlir/include/mlir/Support/StorageUniquer.h

public:
   };
 
   /// This is a utility allocator used to allocate memory for instances of
   /// derived types.
   class StorageAllocator {
   public:
     /// Copy the specified array of elements into memory managed by our bump
     /// pointer allocator.  This assumes the elements are all PODs.
-    template <typename T> ArrayRef<T> copyInto(ArrayRef<T> elements) {
-      if (elements.empty())
+    template <typename RangeT,
+              typename T = std::remove_const_t<std::remove_reference_t<
+                  decltype(*std::begin(std::declval<RangeT>()))>>>
+    ArrayRef<T> copyInto(RangeT elements) {
+      return copyInto(std::begin(elements), std::end(elements));
+    }
+
+    template <typename IteratorT,
+              typename T = std::remove_const_t<std::remove_reference_t<
+                  decltype(*std::declval<IteratorT>())>>>
+    ArrayRef<T> copyInto(IteratorT first, IteratorT last) {
+      if (first == last)
         return llvm::None;
-      auto result = allocator.Allocate<T>(elements.size());
-      std::uninitialized_copy(elements.begin(), elements.end(), result);
-      return ArrayRef<T>(result, elements.size());
+      auto *result = allocator.Allocate<T>(std::distance(first, last));
+      std::uninitialized_copy(first, last, result);
+      return ArrayRef<T>(result, std::distance(first, last));
     }
 
     /// Copy the provided string into memory managed by our bump pointer
     /// allocator.
     StringRef copyInto(StringRef str) {
       auto result = copyInto(ArrayRef<char>(str.data(), str.size()));
       return StringRef(result.data(), str.size());
     }

mlir/include/mlir/Transforms/DialectConversion.h

 
 protected:
   /// See `RewritePattern::RewritePattern` for information on the other
   /// available constructors.
   using RewritePattern::RewritePattern;
   /// Construct a conversion pattern with the given converter, and forward the
   /// remaining arguments to RewritePattern.
   template <typename... Args>
-  ConversionPattern(TypeConverter &typeConverter, Args &&... args)
+  ConversionPattern(TypeConverter &typeConverter, Args &&...args)
       : RewritePattern(std::forward<Args>(args)...),
         typeConverter(&typeConverter) {}
 
 protected:
   /// An optional type converter for use by this pattern.
   TypeConverter *typeConverter = nullptr;
 
 private:
OpConversionPattern(TypeConverter &typeConverter, MLIRContext *context,
                       PatternBenefit benefit = 1)
       : ConversionPattern(typeConverter, SourceOp::getOperationName(), benefit,
                           context) {}
 
   /// Wrappers around the ConversionPattern methods that pass the derived op
   /// type.
   void rewrite(Operation *op, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const final {
-    rewrite(cast<SourceOp>(op), OpAdaptor(operands, op->getAttrDictionary()),
-            rewriter);
+    rewrite(cast<SourceOp>(op),
+            OpAdaptor(getContext(), operands, op->getAttrs()), rewriter);
   }
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     return matchAndRewrite(cast<SourceOp>(op),
-                           OpAdaptor(operands, op->getAttrDictionary()),
+                           OpAdaptor(getContext(), operands, op->getAttrs()),
                            rewriter);
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type and accept the
   /// raw operand values.
   /// NOTICE: These methods are deprecated and will be removed. All new code
   /// should use the adaptor methods below instead.
   virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
                        ConversionPatternRewriter &rewriter) const {
     llvm_unreachable("must override matchAndRewrite or a rewrite method");
   }
   virtual LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const {
     if (failed(match(op)))
       return failure();
-    rewrite(op, OpAdaptor(operands, op->getAttrDictionary()), rewriter);
+    rewrite(op, OpAdaptor(getContext(), operands, op->getAttrs()), rewriter);
     return success();
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
   virtual void rewrite(SourceOp op, OpAdaptor adaptor,
                        ConversionPatternRewriter &rewriter) const {
     ValueRange operands = adaptor.getOperands();

mlir/lib/CAPI/IR/IR.cpp

if (!inferInterface) {
     emitError(state.location)
         << "type inference was requested for the operation " << state.name
         << ", but the operation does not support type inference. Result "
            "types must be specified explicitly.";
     return failure();
   }
 
   if (succeeded(inferInterface->inferReturnTypes(
-          context, state.location, state.operands,
-          state.attributes.getDictionary(context), state.regions, state.types)))
+          context, state.location, state.operands, state.attributes,
+          state.regions, state.types)))
     return success();
 
   // Diagnostic emitted by interface.
   return failure();
 }
 
 MlirOperation mlirOperationCreate(MlirOperationState *state) {
   assert(state);

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

CmpIOpLowering::matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
 
   auto vectorType = resultType.dyn_cast<VectorType>();
   if (!vectorType)
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
       op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
       [&](Type llvm1DVectorTy, ValueRange operands) {
-        OpAdaptor adaptor(operands);
+        OpAdaptor adaptor(getContext(), operands);
         return rewriter.create<LLVM::ICmpOp>(
             op.getLoc(), llvm1DVectorTy,
             convertCmpPredicate<LLVM::ICmpPredicate>(op.getPredicate()),
             adaptor.getLhs(), adaptor.getRhs());
       },
       rewriter);
 
   return success();
CmpFOpLowering::matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
 
   auto vectorType = resultType.dyn_cast<VectorType>();
   if (!vectorType)
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
       op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
       [&](Type llvm1DVectorTy, ValueRange operands) {
-        OpAdaptor adaptor(operands);
+        OpAdaptor adaptor(getContext(), operands);
         return rewriter.create<LLVM::FCmpOp>(
             op.getLoc(), llvm1DVectorTy,
             convertCmpPredicate<LLVM::FCmpPredicate>(op.getPredicate()),
             adaptor.getLhs(), adaptor.getRhs());
       },
       rewriter);
 }
 

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

auto coroSize =
         rewriter.create<LLVM::CoroSizeOp>(loc, rewriter.getI64Type());
 
     // Allocate memory for the coroutine frame.
     auto coroAlloc = rewriter.create<LLVM::CallOp>(
         loc, i8Ptr, SymbolRefAttr::get(rewriter.getContext(), kMalloc),
         ValueRange(coroSize.getResult()));
 
     // Begin a coroutine: @llvm.coro.begin.
-    auto coroId = CoroBeginOpAdaptor(adaptor.getOperands()).id();
+    auto coroId = CoroBeginOpAdaptor(getContext(), adaptor.getOperands()).id();
     rewriter.replaceOpWithNewOp<LLVM::CoroBeginOp>(
         op, i8Ptr, ValueRange({coroId, coroAlloc.getResult(0)}));
 
     return success();
   }
 };
 } // namespace
 

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

 struct DimOpLowering : public ConvertOpToLLVMPattern<memref::DimOp> {
   using ConvertOpToLLVMPattern<memref::DimOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(memref::DimOp dimOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type operandType = dimOp.source().getType();
     if (operandType.isa<UnrankedMemRefType>()) {
-      rewriter.replaceOp(
-          dimOp, {extractSizeOfUnrankedMemRef(
-                     operandType, dimOp, adaptor.getOperands(), rewriter)});
+      rewriter.replaceOp(dimOp, {extractSizeOfUnrankedMemRef(
+                                    operandType, dimOp, adaptor, rewriter)});
 
       return success();
     }
     if (operandType.isa<MemRefType>()) {
-      rewriter.replaceOp(
-          dimOp, {extractSizeOfRankedMemRef(operandType, dimOp,
-                                            adaptor.getOperands(), rewriter)});
+      rewriter.replaceOp(dimOp, {extractSizeOfRankedMemRef(operandType, dimOp,
+                                                           adaptor, rewriter)});
       return success();
     }
     llvm_unreachable("expected MemRefType or UnrankedMemRefType");
   }
 
 private:
   Value extractSizeOfUnrankedMemRef(Type operandType, memref::DimOp dimOp,
                                     OpAdaptor adaptor,

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

static LogicalResult replaceWithLoadOrStore(Operation *op, ValueRange operands,
                                             LLVMTypeConverter &typeConverter,
                                             unsigned alignment, bool isVolatile,
                                             bool isNonTemporal) {
   if (auto loadOp = dyn_cast<spirv::LoadOp>(op)) {
     auto dstType = typeConverter.convertType(loadOp.getType());
     if (!dstType)
       return failure();
     rewriter.replaceOpWithNewOp<LLVM::LoadOp>(
-        loadOp, dstType, spirv::LoadOpAdaptor(operands).ptr(), alignment,
-        isVolatile, isNonTemporal);
+        loadOp, dstType, spirv::LoadOpAdaptor(op->getContext(), operands).ptr(),
+        alignment, isVolatile, isNonTemporal);
     return success();
   }
   auto storeOp = cast<spirv::StoreOp>(op);
-  spirv::StoreOpAdaptor adaptor(operands);
+  spirv::StoreOpAdaptor adaptor(op->getContext(), operands);
   rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeOp, adaptor.value(),
                                              adaptor.ptr(), alignment,
                                              isVolatile, isNonTemporal);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Type conversion

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 
 using namespace mlir;
 
 #define PASS_NAME "convert-std-to-llvm"
 
 /// Only retain those attributes that are not constructed by
 /// `LLVMFuncOp::build`. If `filterArgAttrs` is set, also filter out argument
 /// attributes.
-static void filterFuncAttributes(ArrayRef<NamedAttribute> attrs,
-                                 bool filterArgAttrs,
+static void filterFuncAttributes(AttributeRange attrs, bool filterArgAttrs,
                                  SmallVectorImpl<NamedAttribute> &result) {
   for (const auto &attr : attrs) {
     if (attr.first == SymbolTable::getSymbolAttrName() ||
         attr.first == function_like_impl::getTypeAttrName() ||
         attr.first == "std.varargs" ||
         (filterArgAttrs &&
          attr.first == function_like_impl::getArgDictAttrName()))
       continue;

mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp

static LogicalResult replaceTransferOpWithMubuf(
   return success();
 }
 
 static LogicalResult replaceTransferOpWithMubuf(
     ConversionPatternRewriter &rewriter, ValueRange operands,
     LLVMTypeConverter &typeConverter, Location loc, TransferWriteOp xferOp,
     Type &vecTy, Value &dwordConfig, Value &vindex, Value &offsetSizeInBytes,
     Value &glc, Value &slc) {
-  auto adaptor = TransferWriteOpAdaptor(operands, xferOp->getAttrDictionary());
+  auto adaptor = TransferWriteOpAdaptor(rewriter.getContext(), operands,
+                                        xferOp->getAttrs());
   rewriter.replaceOpWithNewOp<ROCDL::MubufStoreOp>(xferOp, adaptor.vector(),
                                                    dwordConfig, vindex,
                                                    offsetSizeInBytes, glc, slc);
   return success();
 }
 
 namespace {
 /// Conversion pattern that converts a 1-D vector transfer read/write.

mlir/lib/Dialect/Async/IR/Async.cpp

LogicalResult CreateGroupOp::canonicalize(CreateGroupOp op,
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 /// AwaitOp
 //===----------------------------------------------------------------------===//
 
 void AwaitOp::build(OpBuilder &builder, OperationState &result, Value operand,
-                    ArrayRef<NamedAttribute> attrs) {
+                    AttributeRange attrs) {
   result.addOperands({operand});
   result.attributes.append(attrs.begin(), attrs.end());
 
   // Add unwrapped async.value type to the returned values types.
   if (auto valueType = operand.getType().dyn_cast<ValueType>())
     result.addTypes(valueType.getValueType());
 }
 

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

outlineExecuteOp(SymbolTable &symbolTable, ExecuteOp execute) {
 
   // Collect types for the outlined function inputs and outputs.
   auto typesRange = llvm::map_range(
       functionInputs, [](Value value) { return value.getType(); });
   SmallVector<Type, 4> inputTypes(typesRange.begin(), typesRange.end());
   auto outputTypes = execute.getResultTypes();
 
   auto funcType = FunctionType::get(ctx, inputTypes, outputTypes);
-  auto funcAttrs = ArrayRef<NamedAttribute>();
+  auto funcAttrs = AttributeRange();
 
   // TODO: Derive outlined function name from the parent FuncOp (support
   // multiple nested async.execute operations).
   FuncOp func = FuncOp::create(loc, kAsyncFnPrefix, funcType, funcAttrs);
   symbolTable.insert(func);
 
   SymbolTable::setSymbolVisibility(func, SymbolTable::Visibility::Private);
   auto builder = ImplicitLocOpBuilder::atBlockBegin(loc, func.addEntryBlock());

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

BlockArgument GPUFuncOp::addPrivateAttribution(Type type) {
   // Buffers on the private memory always come after buffers on the workgroup
   // memory.
   return getBody().addArgument(type);
 }
 
 void GPUFuncOp::build(OpBuilder &builder, OperationState &result,
                       StringRef name, FunctionType type,
                       TypeRange workgroupAttributions,
-                      TypeRange privateAttributions,
-                      ArrayRef<NamedAttribute> attrs) {
+                      TypeRange privateAttributions, AttributeRange attrs) {
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   result.addAttribute(getNumWorkgroupAttributionsAttrName(),
                       builder.getI64IntegerAttr(workgroupAttributions.size()));
   result.addAttributes(attrs);
   Region *body = result.addRegion();
   Block *entryBlock = new Block;

mlir/lib/Dialect/GPU/Transforms/AsyncRegionRewriter.cpp

if (currentToken)
       return success();
 
     // Clone the op to return a token in addition to the other results.
     SmallVector<Type, 1> resultTypes;
     resultTypes.reserve(1 + op->getNumResults());
     copy(op->getResultTypes(), std::back_inserter(resultTypes));
     resultTypes.push_back(tokenType);
     auto *newOp = Operation::create(op->getLoc(), op->getName(), resultTypes,
-                                    op->getOperands(), op->getAttrDictionary(),
+                                    op->getOperands(), op->getAttrs(),
                                     op->getSuccessors(), op->getNumRegions());
 
     // Clone regions into new op.
     BlockAndValueMapping mapping;
     for (auto pair : llvm::zip_first(op->getRegions(), newOp->getRegions()))
       std::get<0>(pair).cloneInto(&std::get<1>(pair), mapping);
 
     // Replace the op with the async clone.

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

 static constexpr const char kVolatileAttrName[] = "volatile_";
 static constexpr const char kNonTemporalAttrName[] = "nontemporal";
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.cpp.inc"
 #include "mlir/Dialect/LLVMIR/LLVMOpsInterfaces.cpp.inc"
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc"
 
-static auto processFMFAttr(ArrayRef<NamedAttribute> attrs) {
+static auto processFMFAttr(AttributeRange attrs) {
   SmallVector<NamedAttribute, 8> filteredAttrs(
       llvm::make_filter_range(attrs, [&](NamedAttribute attr) {
         if (attr.first == "fastmathFlags") {
           auto defAttr = FMFAttr::get(attr.second.getContext(), {});
           return defAttr != attr.second;
         }
         return true;
       }));
   return filteredAttrs;
 }
 
 static ParseResult parseLLVMOpAttrs(OpAsmParser &parser,
                                     NamedAttrList &result) {
   return parser.parseOptionalAttrDict(result);
 }
 
 static void printLLVMOpAttrs(OpAsmPrinter &printer, Operation *op,
-                             DictionaryAttr attrs) {
-  printer.printOptionalAttrDict(processFMFAttr(attrs.getValue()));
+                             AttributeRange attrs) {
+  printer.printOptionalAttrDict(processFMFAttr(attrs));
 }
 
 /// Verifies `symbol`'s use in `op` to ensure the symbol is a valid and
 /// fully defined llvm.func.
 static LogicalResult verifySymbolAttrUse(FlatSymbolRefAttr symbol,
                                          Operation *op,
                                          SymbolTableCollection &symbolTable) {
   StringRef name = symbol.getValue();

 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::ExtractElementOp.
 //===----------------------------------------------------------------------===//
 // Expects vector to be of wrapped LLVM vector type and position to be of
 // wrapped LLVM i32 type.
 void LLVM::ExtractElementOp::build(OpBuilder &b, OperationState &result,
                                    Value vector, Value position,
-                                   ArrayRef<NamedAttribute> attrs) {
+                                   AttributeRange attrs) {
   auto vectorType = vector.getType();
   auto llvmType = LLVM::getVectorElementType(vectorType);
   build(b, result, llvmType, vector, position);
   result.addAttributes(attrs);
 }
 
 static void printExtractElementOp(OpAsmPrinter &p, ExtractElementOp &op) {
   p << ' ' << op.getVector() << "[" << op.getPosition() << " : "

 
 /// Returns the name used for the unnamed_addr attribute. This *must* correspond
 /// to the name of the attribute in ODS.
 static StringRef getUnnamedAddrAttrName() { return "unnamed_addr"; }
 
 void GlobalOp::build(OpBuilder &builder, OperationState &result, Type type,
                      bool isConstant, Linkage linkage, StringRef name,
                      Attribute value, uint64_t alignment, unsigned addrSpace,
-                     bool dsoLocal, ArrayRef<NamedAttribute> attrs) {
+                     bool dsoLocal, AttributeRange attrs) {
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute("global_type", TypeAttr::get(type));
   if (isConstant)
     result.addAttribute("constant", builder.getUnitAttr());
   if (value)
     result.addAttribute("value", value);
   if (dsoLocal)

 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::ShuffleVectorOp.
 //===----------------------------------------------------------------------===//
 // Expects vector to be of wrapped LLVM vector type and position to be of
 // wrapped LLVM i32 type.
 void LLVM::ShuffleVectorOp::build(OpBuilder &b, OperationState &result,
                                   Value v1, Value v2, ArrayAttr mask,
-                                  ArrayRef<NamedAttribute> attrs) {
+                                  AttributeRange attrs) {
   auto containerType = v1.getType();
   auto vType = LLVM::getFixedVectorType(
       LLVM::getVectorElementType(containerType), mask.size());
   build(b, result, vType, v1, v2, mask);
   result.addAttributes(attrs);
 }
 
 static void printShuffleVectorOp(OpAsmPrinter &p, ShuffleVectorOp &op) {
Block *LLVMFuncOp::addEntryBlock() {
   LLVMFunctionType type = getType();
   for (unsigned i = 0, e = type.getNumParams(); i < e; ++i)
     entry->addArgument(type.getParamType(i));
   return entry;
 }
 
 void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
                        StringRef name, Type type, LLVM::Linkage linkage,
-                       bool dsoLocal, ArrayRef<NamedAttribute> attrs,
+                       bool dsoLocal, AttributeRange attrs,
                        ArrayRef<DictionaryAttr> argAttrs) {
   result.addRegion();
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute("type", TypeAttr::get(type));
   result.addAttribute(::getLinkageAttrName(),
                       LinkageAttr::get(builder.getContext(), linkage));
   result.attributes.append(attrs.begin(), attrs.end());

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 //===----------------------------------------------------------------------===//
 void CopyOp::regionBuilder(ImplicitLocOpBuilder &b, Block &block) {
   assert(block.getNumArguments() == 2 && "CopyOp regionBuilder expects 2 args");
   b.create<linalg::YieldOp>(block.getArgument(0));
 }
 
 void CopyOp::build(OpBuilder &builder, OperationState &result, Value input,
                    Value output, AffineMap inputPermutation,
-                   AffineMap outputPermutation,
-                   ArrayRef<NamedAttribute> namedAttrs) {
+                   AffineMap outputPermutation, AttributeRange namedAttrs) {
   result.addOperands({input, output});
   result.addAttributes(namedAttrs);
   if (inputPermutation)
     result.addAttribute("inputPermutation",
                         AffineMapAttr::get(inputPermutation));
   if (outputPermutation)
     result.addAttribute("outputPermutation",
                         AffineMapAttr::get(outputPermutation));

 //===----------------------------------------------------------------------===//
 // GenericOps
 //===----------------------------------------------------------------------===//
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, TypeRange resultTensorTypes,
     ValueRange inputs, ValueRange outputs, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes, StringRef doc, StringRef libraryCall,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
-    ArrayRef<NamedAttribute> attributes) {
+    AttributeRange attributes) {
   build(builder, result, resultTensorTypes, inputs, outputs,
         builder.getAffineMapArrayAttr(indexingMaps),
         builder.getStrArrayAttr(iteratorTypes),
         doc.empty() ? StringAttr() : builder.getStringAttr(doc),
         libraryCall.empty() ? StringAttr()
                             : builder.getStringAttr(libraryCall));
   result.addAttributes(attributes);
   if (!bodyBuild)
void GenericOp::build(
   bodyBuild(builder, result.location, bodyBlock->getArguments());
 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs,
     ValueRange outputs, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes, StringRef doc, StringRef libraryCall,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
-    ArrayRef<NamedAttribute> attributes) {
+    AttributeRange attributes) {
   build(builder, result, TypeRange{}, inputs, outputs, indexingMaps,
         iteratorTypes, doc, libraryCall, bodyBuild, attributes);
 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs,
     ValueRange outputs, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
-    ArrayRef<NamedAttribute> attributes) {
+    AttributeRange attributes) {
   build(builder, result, inputs, outputs, indexingMaps, iteratorTypes,
         /*doc=*/"",
         /*libraryCall=*/"", bodyBuild, attributes);
 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, TypeRange resultTensorTypes,
     ValueRange inputs, ValueRange outputs, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
-    ArrayRef<NamedAttribute> attributes) {
+    AttributeRange attributes) {
   build(builder, result, resultTensorTypes, inputs, outputs, indexingMaps,
         iteratorTypes,
         /*doc=*/"",
         /*libraryCall=*/"", bodyBuild, attributes);
 }
 
 static void print(OpAsmPrinter &p, GenericOp op) {
   p << " ";
void GenericOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<DeduplicateGenericOpInputs, EraseIdentityGenericOp>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // InitTensorOp
 //===----------------------------------------------------------------------===//
 void InitTensorOp::build(OpBuilder &b, OperationState &result,
                          ArrayRef<OpFoldResult> sizes, Type elementType,
-                         ArrayRef<NamedAttribute> attrs) {
+                         AttributeRange attrs) {
   unsigned rank = sizes.size();
   SmallVector<Value, 4> dynamicSizes;
   SmallVector<int64_t, 4> staticSizes;
   for (unsigned i = 0; i < rank; ++i) {
     dispatchIndexOpFoldResult(sizes[i], dynamicSizes, staticSizes,
                               ShapedType::kDynamicSize);
   }
   auto resultType = RankedTensorType ::get(staticSizes, elementType);
RankedTensorType PadTensorOp::inferResultType(RankedTensorType sourceType,
   }
 
   return RankedTensorType::get(inferredShape, sourceType.getElementType());
 }
 
 void PadTensorOp::build(OpBuilder &b, OperationState &result, Value source,
                         ArrayRef<int64_t> staticLow,
                         ArrayRef<int64_t> staticHigh, ValueRange low,
-                        ValueRange high, bool nofold,
-                        ArrayRef<NamedAttribute> attrs) {
+                        ValueRange high, bool nofold, AttributeRange attrs) {
   auto sourceType = source.getType().cast<RankedTensorType>();
   auto resultType = inferResultType(sourceType, staticLow, staticHigh);
   build(b, result, resultType, source, low, high, b.getI64ArrayAttr(staticLow),
         b.getI64ArrayAttr(staticHigh), nofold ? b.getUnitAttr() : UnitAttr());
   result.addAttributes(attrs);
 }
 
 void PadTensorOp::build(OpBuilder &b, OperationState &result, Value source,
                         ValueRange low, ValueRange high, bool nofold,
-                        ArrayRef<NamedAttribute> attrs) {
+                        AttributeRange attrs) {
   auto sourceType = source.getType().cast<RankedTensorType>();
   unsigned rank = sourceType.getRank();
   SmallVector<int64_t, 4> staticVector(rank, ShapedType::kDynamicSize);
   build(b, result, source, staticVector, staticVector, low, high, nofold,
         attrs);
 }
 
 void PadTensorOp::build(OpBuilder &b, OperationState &result, Type resultType,
                         Value source, ArrayRef<OpFoldResult> low,
                         ArrayRef<OpFoldResult> high, bool nofold,
-                        ArrayRef<NamedAttribute> attrs) {
+                        AttributeRange attrs) {
   assert(resultType.isa<RankedTensorType>());
   auto sourceType = source.getType().cast<RankedTensorType>();
   unsigned rank = sourceType.getRank();
   SmallVector<Value, 4> dynamicLow, dynamicHigh;
   SmallVector<int64_t, 4> staticLow, staticHigh;
   for (unsigned i = 0; i < rank; ++i) {
     // staticLow and staticHigh have full information of the padding config.
     // This will grow staticLow and staticHigh with 1 value. If the config is
for (AffineMap m : reassociation) {
     currentDim += dim;
   }
 
   return RankedTensorType::get(newShape, type.getElementType());
 }
 
 void mlir::linalg::TensorCollapseShapeOp::build(
     OpBuilder &b, OperationState &result, Value src,
-    ArrayRef<ReassociationIndices> reassociation,
-    ArrayRef<NamedAttribute> attrs) {
+    ArrayRef<ReassociationIndices> reassociation, AttributeRange attrs) {
   auto resultType = computeTensorReshapeCollapsedType(
       src.getType().cast<RankedTensorType>(),
       getSymbolLessAffineMaps(
           convertReassociationIndicesToExprs(b.getContext(), reassociation)));
   build(b, result, resultType, src, attrs);
   result.addAttribute(getReassociationAttrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }
 
 void mlir::linalg::TensorExpandShapeOp::build(
     OpBuilder &b, OperationState &result, Value src,
-    ArrayRef<ReassociationIndices> reassociation,
-    ArrayRef<NamedAttribute> attrs) {
+    ArrayRef<ReassociationIndices> reassociation, AttributeRange attrs) {
   auto resultType = computeTensorReshapeCollapsedType(
       src.getType().cast<RankedTensorType>(),
       getSymbolLessAffineMaps(
           convertReassociationIndicesToExprs(b.getContext(), reassociation)));
   build(b, result, resultType, src, attrs);
   result.addAttribute(getReassociationAttrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }

mlir/lib/Dialect/Linalg/Transforms/Bufferize.cpp

matchAndRewrite(LinalgOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     // GenericOpAdaptor below expects an `operand_segment_sizes` attribute.
     if (!op->hasAttr("operand_segment_sizes"))
       return failure();
 
     // We abuse the GenericOpAdaptor here.
     // TODO: Manually create an Adaptor that captures inputs and outputs for all
     // linalg::LinalgOp interface ops.
-    linalg::GenericOpAdaptor adaptor(operands, op->getAttrDictionary());
+    linalg::GenericOpAdaptor adaptor(getContext(), operands, op->getAttrs());
 
     Location loc = op.getLoc();
     SmallVector<Value, 2> newOutputBuffers;
 
     if (failed(allocateBuffersForResults(loc, op, adaptor.outputs(),
                                          newOutputBuffers, rewriter))) {
       return op.emitOpError()
              << "Failed to allocate buffers for tensor results.";

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 
 /// Build a ReinterpretCastOp with all dynamic entries: `staticOffsets`,
 /// `staticSizes` and `staticStrides` are automatically filled with
 /// source-memref-rank sentinel values that encode dynamic entries.
 void ReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                               MemRefType resultType, Value source,
                               OpFoldResult offset, ArrayRef<OpFoldResult> sizes,
                               ArrayRef<OpFoldResult> strides,
-                              ArrayRef<NamedAttribute> attrs) {
+                              AttributeRange attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offset, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamicStrideOrOffset);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamicSize);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamicStrideOrOffset);
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getI64ArrayAttr(staticOffsets),
         b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 void ReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                               MemRefType resultType, Value source,
                               int64_t offset, ArrayRef<int64_t> sizes,
-                              ArrayRef<int64_t> strides,
-                              ArrayRef<NamedAttribute> attrs) {
+                              ArrayRef<int64_t> strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> sizeValues =
       llvm::to_vector<4>(llvm::map_range(sizes, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   build(b, result, resultType, source, b.getI64IntegerAttr(offset), sizeValues,
         strideValues, attrs);
 }
 
 void ReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                               MemRefType resultType, Value source, Value offset,
                               ValueRange sizes, ValueRange strides,
-                              ArrayRef<NamedAttribute> attrs) {
+                              AttributeRange attrs) {
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offset, sizeValues, strideValues, attrs);
 }
 
 // TODO: ponder whether we want to allow missing trailing sizes/strides that are
auto layout =
       makeStridedLinearLayoutMap(intStrides, intOffset, type.getContext());
   return canonicalizeStridedLayout(
       MemRefType::Builder(type).setShape(newSizes).setLayout(
           AffineMapAttr::get(layout)));
 }
 
 void ExpandShapeOp::build(OpBuilder &b, OperationState &result, Value src,
                           ArrayRef<ReassociationIndices> reassociation,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   auto memRefType = src.getType().cast<MemRefType>();
   auto resultType = computeReshapeCollapsedType(
       memRefType, getSymbolLessAffineMaps(convertReassociationIndicesToExprs(
                       b.getContext(), reassociation)));
   build(b, result, resultType, src, attrs);
   result.addAttribute(getReassociationAttrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }
 
 void CollapseShapeOp::build(OpBuilder &b, OperationState &result, Value src,
                             ArrayRef<ReassociationIndices> reassociation,
-                            ArrayRef<NamedAttribute> attrs) {
+                            AttributeRange attrs) {
   auto memRefType = src.getType().cast<MemRefType>();
   auto resultType = computeReshapeCollapsedType(
       memRefType, getSymbolLessAffineMaps(convertReassociationIndicesToExprs(
                       b.getContext(), reassociation)));
   build(b, result, resultType, src, attrs);
   result.addAttribute(getReassociationAttrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }
return SubViewOp::inferRankReducedResultType(
       staticStrides);
 }
 // Build a SubViewOp with mixed static and dynamic entries and custom result
 // type. If the type passed is nullptr, it is inferred.
 void SubViewOp::build(OpBuilder &b, OperationState &result,
                       MemRefType resultType, Value source,
                       ArrayRef<OpFoldResult> offsets,
                       ArrayRef<OpFoldResult> sizes,
-                      ArrayRef<OpFoldResult> strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      ArrayRef<OpFoldResult> strides, AttributeRange attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamicStrideOrOffset);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamicSize);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamicStrideOrOffset);
void SubViewOp::build(OpBuilder &b, OperationState &result,
   result.addAttributes(attrs);
 }
 
 // Build a SubViewOp with mixed static and dynamic entries and inferred result
 // type.
 void SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
                       ArrayRef<OpFoldResult> offsets,
                       ArrayRef<OpFoldResult> sizes,
-                      ArrayRef<OpFoldResult> strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      ArrayRef<OpFoldResult> strides, AttributeRange attrs) {
   build(b, result, MemRefType(), source, offsets, sizes, strides, attrs);
 }
 
 // Build a SubViewOp with static entries and inferred result type.
 void SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
                       ArrayRef<int64_t> offsets, ArrayRef<int64_t> sizes,
-                      ArrayRef<int64_t> strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      ArrayRef<int64_t> strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> sizeValues =
       llvm::to_vector<4>(llvm::map_range(sizes, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   build(b, result, source, offsetValues, sizeValues, strideValues, attrs);
 }
 
 // Build a SubViewOp with dynamic entries and custom result type. If the
 // type passed is nullptr, it is inferred.
 void SubViewOp::build(OpBuilder &b, OperationState &result,
                       MemRefType resultType, Value source,
                       ArrayRef<int64_t> offsets, ArrayRef<int64_t> sizes,
-                      ArrayRef<int64_t> strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      ArrayRef<int64_t> strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> sizeValues =
       llvm::to_vector<4>(llvm::map_range(sizes, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [&](int64_t v) -> OpFoldResult {
         return b.getI64IntegerAttr(v);
       }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues,
         attrs);
 }
 
 // Build a SubViewOp with dynamic entries and custom result type. If the type
 // passed is nullptr, it is inferred.
 void SubViewOp::build(OpBuilder &b, OperationState &result,
                       MemRefType resultType, Value source, ValueRange offsets,
                       ValueRange sizes, ValueRange strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues);
 }
 
 // Build a SubViewOp with dynamic entries and inferred result type.
 void SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
                       ValueRange offsets, ValueRange sizes, ValueRange strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      AttributeRange attrs) {
   build(b, result, MemRefType(), source, offsets, sizes, strides, attrs);
 }
 
 /// For ViewLikeOpInterface.
 Value SubViewOp::getViewSource() { return source(); }
 
 enum SubViewVerificationResult {
   Success,
auto map =
       makeStridedLinearLayoutMap(strides, offset, memRefType.getContext());
   map = permutationMap ? map.compose(permutationMap) : map;
   return MemRefType::Builder(memRefType)
       .setShape(sizes)
       .setLayout(AffineMapAttr::get(map));
 }
 
 void TransposeOp::build(OpBuilder &b, OperationState &result, Value in,
-                        AffineMapAttr permutation,
-                        ArrayRef<NamedAttribute> attrs) {
+                        AffineMapAttr permutation, AttributeRange attrs) {
   auto permutationMap = permutation.getValue();
   assert(permutationMap);
 
   auto memRefType = in.getType().cast<MemRefType>();
   // Compute result type.
   MemRefType resultType = inferTransposeResultType(memRefType, permutationMap);
 
   build(b, result, resultType, in, attrs);

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

#include "mlir/Dialect/OpenMP/OpenMPOps.cpp.inc"
   MemRefType::attachInterface<PointerLikeModel<MemRefType>>(*getContext());
 }
 
 //===----------------------------------------------------------------------===//
 // ParallelOp
 //===----------------------------------------------------------------------===//
 
 void ParallelOp::build(OpBuilder &builder, OperationState &state,
-                       ArrayRef<NamedAttribute> attributes) {
+                       AttributeRange attributes) {
   ParallelOp::build(
       builder, state, /*if_expr_var=*/nullptr, /*num_threads_var=*/nullptr,
       /*default_val=*/nullptr, /*private_vars=*/ValueRange(),
       /*firstprivate_vars=*/ValueRange(), /*shared_vars=*/ValueRange(),
       /*copyin_vars=*/ValueRange(), /*allocate_vars=*/ValueRange(),
       /*allocators_vars=*/ValueRange(), /*proc_bind_val=*/nullptr);
   state.addAttributes(attributes);
 }

 }
 
 //===----------------------------------------------------------------------===//
 // WsLoopOp
 //===----------------------------------------------------------------------===//
 
 void WsLoopOp::build(OpBuilder &builder, OperationState &state,
                      ValueRange lowerBound, ValueRange upperBound,
-                     ValueRange step, ArrayRef<NamedAttribute> attributes) {
+                     ValueRange step, AttributeRange attributes) {
   build(builder, state, TypeRange(), lowerBound, upperBound, step,
         /*private_vars=*/ValueRange(),
         /*firstprivate_vars=*/ValueRange(), /*lastprivate_vars=*/ValueRange(),
         /*linear_vars=*/ValueRange(), /*linear_step_vars=*/ValueRange(),
         /*reduction_vars=*/ValueRange(), /*schedule_val=*/nullptr,
         /*schedule_chunk_var=*/nullptr, /*collapse_val=*/nullptr,
         /*nowait=*/nullptr, /*ordered_val=*/nullptr, /*order_val=*/nullptr,
         /*inclusive=*/nullptr, /*buildBody=*/false);
   state.addAttributes(attributes);
 }
 
 void WsLoopOp::build(OpBuilder &, OperationState &state, TypeRange resultTypes,
-                     ValueRange operands, ArrayRef<NamedAttribute> attributes) {
+                     ValueRange operands, AttributeRange attributes) {
   state.addOperands(operands);
   state.addAttributes(attributes);
   (void)state.addRegion();
   assert(resultTypes.empty() && "mismatched number of return types");
   state.addTypes(resultTypes);
 }
 
 void WsLoopOp::build(OpBuilder &builder, OperationState &result,

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

LogicalResult canCanonicalizeSelection(Block *trueBlock, Block *falseBlock,
                                          Block *mergeBlock) const;
 
   bool onlyContainsBranchConditionalOp(Block *block) const {
     return std::next(block->begin()) == block->end() &&
            isa<spirv::BranchConditionalOp>(block->front());
   }
 
   bool isSameAttrList(spirv::StoreOp lhs, spirv::StoreOp rhs) const {
-    return lhs->getAttrDictionary() == rhs->getAttrDictionary();
+    return lhs->getAttrs() == rhs->getAttrs();
   }
 
   // Returns a source value for the given block.
   Value getSrcValue(Block *block) const {
     auto storeOp = cast<spirv::StoreOp>(block->front());
     return storeOp.value();
   }
 

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

LogicalResult spirv::FuncOp::verifyBody() {
   // TODO: verify other bits like linkage type.
 
   return failure(walkResult.wasInterrupted());
 }
 
 void spirv::FuncOp::build(OpBuilder &builder, OperationState &state,
                           StringRef name, FunctionType type,
                           spirv::FunctionControl control,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   state.addAttribute(SymbolTable::getSymbolAttrName(),
                      builder.getStringAttr(name));
   state.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   state.addAttribute(spirv::attributeName<spirv::FunctionControl>(),
                      builder.getI32IntegerAttr(static_cast<uint32_t>(control)));
   state.attributes.append(attrs.begin(), attrs.end());
   state.addRegion();
 }

mlir/lib/Dialect/Shape/IR/Shape.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::AddOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<SizeType>() ||
       operands[1].getType().isa<SizeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }

 
 void ConstShapeOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                MLIRContext *context) {
   patterns.add<TensorCastConstShape>(context);
 }
 
 LogicalResult mlir::shape::ConstShapeOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   Builder b(context);
   auto shape = attributes.getAs<DenseIntElementsAttr>("shape");
   if (!shape)
     return emitOptionalError(location, "missing shape attribute");
   inferredReturnTypes.assign({RankedTensorType::get(
       {static_cast<int64_t>(shape.size())}, b.getIndexType())});
   return success();
OpFoldResult DivOp::fold(ArrayRef<Attribute> operands) {
   }
 
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, quotient);
 }
 
 LogicalResult mlir::shape::DivOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<SizeType>() ||
       operands[1].getType().isa<SizeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
if (shape.getType().isa<ShapeType>()) {
     Value dim =
         builder.create<arith::ConstantOp>(loc, builder.getIndexType(), dimAttr);
     build(builder, result, builder.getIndexType(), shape, dim);
   }
 }
 
 LogicalResult mlir::shape::GetExtentOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::GetExtentOp::isCompatibleReturnTypes(TypeRange l,
                                                        TypeRange r) {
   // SizeType is compatible with IndexType.

 }
 
 //===----------------------------------------------------------------------===//
 // MeetOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::MeetOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   inferredReturnTypes.assign({operands[0].getType()});
   return success();
 }
 
 bool mlir::shape::MeetOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;

 
 void shape::RankOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                 MLIRContext *context) {
   patterns.add<RankShapeOfCanonicalizationPattern>(context);
 }
 
 LogicalResult mlir::shape::RankOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ShapeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
OpFoldResult NumElementsOp::fold(ArrayRef<Attribute> operands) {
   for (auto value : shape.cast<DenseIntElementsAttr>())
     product *= value;
   Builder builder(getContext());
   return builder.getIndexAttr(product.getLimitedValue());
 }
 
 LogicalResult mlir::shape::NumElementsOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ShapeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
OpFoldResult MaxOp::fold(llvm::ArrayRef<mlir::Attribute> operands) {
   // If operands are equal, just propagate one.
   if (getLhs() == getRhs())
     return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MaxOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() == operands[1].getType())
     inferredReturnTypes.assign({operands[0].getType()});
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
OpFoldResult MinOp::fold(llvm::ArrayRef<mlir::Attribute> operands) {
   // If operands are equal, just propagate one.
   if (getLhs() == getRhs())
     return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MinOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() == operands[1].getType())
     inferredReturnTypes.assign({operands[0].getType()});
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
if (!rhs)
     return nullptr;
   APInt folded = lhs.getValue() * rhs.getValue();
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, folded);
 }
 
 LogicalResult mlir::shape::MulOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<SizeType>() ||
       operands[1].getType().isa<SizeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }

 void ShapeOfOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                             MLIRContext *context) {
   patterns.add<ShapeOfCastExtentTensor, ShapeOfWithTensor,
                ExtractFromShapeOfExtentTensor>(context);
 }
 
 LogicalResult mlir::shape::ShapeOfOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ValueShapeType>())
     inferredReturnTypes.assign({ShapeType::get(context)});
   else {
     auto shapedTy = operands[0].getType().cast<ShapedType>();
     int64_t rank =
         shapedTy.hasRank() ? shapedTy.getRank() : ShapedType::kDynamicSize;
     Type indexTy = IndexType::get(context);

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

 
 /// Build an ExtractSliceOp with mixed static and dynamic entries and custom
 /// result type. If the type passed is nullptr, it is inferred.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result,
                            RankedTensorType resultType, Value source,
                            ArrayRef<OpFoldResult> offsets,
                            ArrayRef<OpFoldResult> sizes,
                            ArrayRef<OpFoldResult> strides,
-                           ArrayRef<NamedAttribute> attrs) {
+                           AttributeRange attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamicStrideOrOffset);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamicSize);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamicStrideOrOffset);

 }
 
 /// Build an ExtractSliceOp with mixed static and dynamic entries and inferred
 /// result type.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                            ArrayRef<OpFoldResult> offsets,
                            ArrayRef<OpFoldResult> sizes,
                            ArrayRef<OpFoldResult> strides,
-                           ArrayRef<NamedAttribute> attrs) {
+                           AttributeRange attrs) {
   build(b, result, RankedTensorType(), source, offsets, sizes, strides, attrs);
 }
 
 /// Build an ExtractSliceOp with dynamic entries and custom result type. If the
 /// type passed is nullptr, it is inferred.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result,
                            RankedTensorType resultType, Value source,
                            ValueRange offsets, ValueRange sizes,
-                           ValueRange strides, ArrayRef<NamedAttribute> attrs) {
+                           ValueRange strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues);
 }
 
 /// Build an ExtractSliceOp with dynamic entries and inferred result type.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                            ValueRange offsets, ValueRange sizes,
-                           ValueRange strides, ArrayRef<NamedAttribute> attrs) {
+                           ValueRange strides, AttributeRange attrs) {
   build(b, result, RankedTensorType(), source, offsets, sizes, strides, attrs);
 }
 
 enum SliceVerificationResult {
   Success,
   RankTooLarge,
   SizeMismatch,
   ElemTypeMismatch,

 // InsertSliceOp
 //===----------------------------------------------------------------------===//
 
 // Build a InsertSliceOp with mixed static and dynamic entries.
 void InsertSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                           Value dest, ArrayRef<OpFoldResult> offsets,
                           ArrayRef<OpFoldResult> sizes,
                           ArrayRef<OpFoldResult> strides,
-                          ArrayRef<NamedAttribute> attrs) {
+                          AttributeRange attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
                              ShapedType::kDynamicStrideOrOffset);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
                              ShapedType::kDynamicSize);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
                              ShapedType::kDynamicStrideOrOffset);
   build(b, result, dest.getType(), source, dest, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getI64ArrayAttr(staticOffsets),
         b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 // Build a InsertSliceOp with dynamic entries.
 void InsertSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                           Value dest, ValueRange offsets, ValueRange sizes,
-                          ValueRange strides, ArrayRef<NamedAttribute> attrs) {
+                          ValueRange strides, AttributeRange attrs) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, source, dest, offsetValues, sizeValues, strideValues);
 }

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

 static void getF64Values(ArrayAttr arrayAttr, SmallVector<double> &values) {
   for (auto it : arrayAttr) {
     values.push_back(it.cast<FloatAttr>().getValueAsDouble());
   }
 }
 
 LogicalResult tosa::ArgMaxOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   IntegerAttr axis = attributes.get("axis").cast<IntegerAttr>();
   int32_t axisVal = axis.getValue().getSExtValue();
 
   if (!inputShape.hasRank()) {
     inferredReturnShapes.push_back(ShapedTypeComponents());
     return success();
   }
 
   SmallVector<int64_t> outShape;
   outShape.reserve(inputShape.getRank() - 1);
   for (int i = 0, s = inputShape.getRank(); i < s; i++) {
     if (i == axisVal)
       continue;
     outShape.push_back(inputShape.getDimSize(i));
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::ConcatOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   // Infer all dimension sizes by reducing based on inputs.
   int32_t axis =
       attributes.get("axis").cast<IntegerAttr>().getValue().getSExtValue();
   llvm::SmallVector<int64_t> outputShape;
   bool hasRankedInput = false;
   for (auto operand : operands) {
     ShapeAdaptor operandShape = operands.getShape(operand);
LogicalResult tosa::ConcatOp::inferReturnTypeComponents(
   outputShape[axis] = concatDimSize;
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::FullyConnectedOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor weightShape = operands.getShape(1);
   ShapeAdaptor biasShape = operands.getShape(2);
 
   // All shapes are dynamic.
   SmallVector<int64_t> outShape;
   outShape.resize(2, ShapedType::kDynamicSize);
LogicalResult tosa::FullyConnectedOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::MatMulOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor lhsShape = operands.getShape(0);
   ShapeAdaptor rhsShape = operands.getShape(1);
 
   // All shapes are dynamic.
   SmallVector<int64_t> outShape;
   outShape.resize(3, ShapedType::kDynamicSize);
 
LogicalResult tosa::MatMulOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::PadOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor paddingShape = operands.getShape(1);
   SmallVector<int64_t> outputShape;
 
   // If both inputs have unknown shape, we cannot determine the shape of the
   // output.
   if (!inputShape.hasRank() && !paddingShape.hasRank()) {
LogicalResult tosa::PadOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::SliceOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  ArrayAttr sizes = SliceOpAdaptor(operands, attributes).size();
+  ArrayAttr sizes = SliceOpAdaptor(context, operands, attributes).size();
   SmallVector<int64_t> outputShape;
   outputShape.reserve(sizes.size());
   for (auto val : sizes) {
     outputShape.push_back(val.cast<IntegerAttr>().getValue().getSExtValue());
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::TableOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
 
   if (!inputShape.hasRank()) {
     inferredReturnShapes.push_back(ShapedTypeComponents());
     return success();
   }
 
   inferredReturnShapes.resize(1);
   inputShape.getDims(inferredReturnShapes[0]);
   return success();
 }
 
 LogicalResult tosa::TileOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  TileOpAdaptor adaptor(operands, attributes);
+  TileOpAdaptor adaptor(context, operands, attributes);
   ArrayAttr multiples = adaptor.multiples();
   ShapeAdaptor inputShape = operands.getShape(0);
   SmallVector<int64_t> outputShape;
   if (!inputShape.hasRank()) {
     outputShape.resize(multiples.size(), ShapedType::kDynamicSize);
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
LogicalResult tosa::TileOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ReshapeOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  ReshapeOpAdaptor adaptor(operands, attributes);
+  ReshapeOpAdaptor adaptor(context, operands, attributes);
   ShapeAdaptor inputShape = operands.getShape(0);
 
   ArrayAttr newShape = adaptor.new_shape();
   llvm::SmallVector<int64_t> newShapeValue;
   getI64Values(newShape, newShapeValue);
 
   // We cannot infer from the total number of elements so we must take the
   // shape attribute as exact.
LogicalResult tosa::ReshapeOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(newShapeValue));
   return success();
 }
 
 LogicalResult tosa::TransposeOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor permsShape = operands.getShape(1);
 
   // If input rank and permutation length is unknown, the output rank is
   // unknown.
   if (!inputShape.hasRank() || !permsShape.hasRank() ||
       permsShape.isDynamicDim(0)) {
LogicalResult tosa::TransposeOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::GatherOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape;
   outputShape.resize(3, ShapedType::kDynamicSize);
 
   ShapeAdaptor valuesShape = operands.getShape(0);
   if (valuesShape.hasRank()) {
     outputShape[0] = valuesShape.getDimSize(0);
     outputShape[2] = valuesShape.getDimSize(2);
   }
 
   ShapeAdaptor indicesShape = operands.getShape(1);
   if (indicesShape.hasRank()) {
     if (outputShape[0] == ShapedType::kDynamicSize)
       outputShape[0] = indicesShape.getDimSize(0);
     if (outputShape[1] == ShapedType::kDynamicSize)
       outputShape[1] = indicesShape.getDimSize(1);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ResizeOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  ResizeOpAdaptor adaptor(operands, attributes);
+  ResizeOpAdaptor adaptor(context, operands, attributes);
   llvm::SmallVector<int64_t, 4> outputShape;
   outputShape.resize(4, ShapedType::kDynamicSize);
 
   int32_t inHeight = ShapedType::kDynamicSize;
   int32_t inWidth = ShapedType::kDynamicSize;
 
   ShapeAdaptor inputShape = operands.getShape(adaptor.input());
   if (inputShape.hasRank()) {
LogicalResult tosa::ResizeOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ScatterOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape;
   outputShape.resize(3, ShapedType::kDynamicSize);
 
   ShapeAdaptor valuesInShape = operands.getShape(0);
   if (valuesInShape.hasRank()) {
     outputShape[0] = valuesInShape.getDimSize(0);
     outputShape[1] = valuesInShape.getDimSize(1);
static LogicalResult ReduceInferReturnTypes(
   outputShape[axisVal] = 1;
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 #define REDUCE_SHAPE_INFER(OP)                                                 \
   LogicalResult OP::inferReturnTypeComponents(                                 \
       MLIRContext *context, ::llvm::Optional<Location> location,               \
-      ValueShapeRange operands, DictionaryAttr attributes,                     \
+      ValueShapeRange operands, AttributeRange attributes,                     \
       RegionRange regions,                                                     \
       SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {           \
     return ReduceInferReturnTypes(operands.getShape(0),                        \
                                   attributes.get("axis").cast<IntegerAttr>(),  \
                                   inferredReturnShapes);                       \
   }
 
 REDUCE_SHAPE_INFER(tosa::ReduceAllOp)
if (resolveBroadcastShape(operands, outShape).failed()) {
     inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   }
   return success();
 }
 
 #define NARY_SHAPE_INFER(OP)                                                   \
   LogicalResult OP::inferReturnTypeComponents(                                 \
       MLIRContext *context, ::llvm::Optional<Location> location,               \
-      ValueShapeRange operands, DictionaryAttr attributes,                     \
+      ValueShapeRange operands, AttributeRange attributes,                     \
       RegionRange regions,                                                     \
       SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {           \
     return NAryInferReturnTypes(operands, inferredReturnShapes);               \
   }
 
 NARY_SHAPE_INFER(tosa::AbsOp)
 NARY_SHAPE_INFER(tosa::AddOp)
 NARY_SHAPE_INFER(tosa::ArithmeticRightShiftOp)

 NARY_SHAPE_INFER(tosa::RsqrtOp)
 NARY_SHAPE_INFER(tosa::SelectOp)
 NARY_SHAPE_INFER(tosa::SubOp)
 NARY_SHAPE_INFER(tosa::TanhOp)
 NARY_SHAPE_INFER(tosa::SigmoidOp)
 #undef PRED_SHAPE_INFER
 
 static LogicalResult poolingInferReturnTypes(
-    const ValueShapeRange &operands, DictionaryAttr attributes,
+    const ValueShapeRange &operands, AttributeRange attributes,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   llvm::SmallVector<int64_t> outputShape;
   outputShape.resize(4, -1);
 
   // We only know the rank if the input type is unranked.
   if (!inputShape) {
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
static LogicalResult poolingInferReturnTypes(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult Conv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(4, ShapedType::kDynamicSize);
-  Conv2DOp::Adaptor adaptor(operands.getValues(), attributes);
+  Conv2DOp::Adaptor adaptor(context, operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t weightWidth = ShapedType::kDynamicSize;
   int32_t weightHeight = ShapedType::kDynamicSize;
 
   // Input shape describes input width/height and batch.
 
LogicalResult Conv2DOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult Conv3DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(5, ShapedType::kDynamicSize);
-  Conv2DOp::Adaptor adaptor(operands.getValues(), attributes);
+  Conv2DOp::Adaptor adaptor(context, operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t inputDepth = ShapedType::kDynamicSize;
 
   int32_t weightWidth = ShapedType::kDynamicSize;
   int32_t weightHeight = ShapedType::kDynamicSize;
   int32_t weightDepth = ShapedType::kDynamicSize;
LogicalResult Conv3DOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult AvgPool2dOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult MaxPool2dOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult DepthwiseConv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(4, ShapedType::kDynamicSize);
-  DepthwiseConv2DOp::Adaptor adaptor(operands.getValues(), attributes);
+  DepthwiseConv2DOp::Adaptor adaptor(context, operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t inputChannels = ShapedType::kDynamicSize;
 
   int32_t weightWidth = ShapedType::kDynamicSize;
   int32_t weightHeight = ShapedType::kDynamicSize;
   int32_t depthChannels = ShapedType::kDynamicSize;
LogicalResult DepthwiseConv2DOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult TransposeConv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  TransposeConv2DOp::Adaptor adaptor(operands.getValues(), attributes);
+  TransposeConv2DOp::Adaptor adaptor(context, operands.getValues(), attributes);
   llvm::SmallVector<int64_t> outputShape;
   getI64Values(adaptor.out_shape(), outputShape);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t weightWidth = ShapedType::kDynamicSize;
   int32_t weightHeight = ShapedType::kDynamicSize;
 
LogicalResult TransposeConv2DOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult IfOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<tosa::YieldOp> yieldOps;
   for (Region *region : regions) {
     for (auto &block : *region)
       if (auto returnOp = dyn_cast<tosa::YieldOp>(block.getTerminator()))
         yieldOps.push_back(returnOp);
   }
 
for (const ValueKnowledge &result : resultKnowledge) {
     inferredReturnShapes.push_back(result.getShapedTypeComponents());
   }
 
   return success();
 }
 
 LogicalResult WhileOp::inferReturnTypeComponents(
     MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    ValueShapeRange operands, AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<tosa::YieldOp> yieldOps;
   for (auto &block : *regions[1])
     if (auto returnOp = dyn_cast<tosa::YieldOp>(block.getTerminator()))
       yieldOps.push_back(returnOp);
 
   // TOSA's while must have a tosa.yield as its terminator. If not found this
   // tosa.while is invalid.

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

for (Operation &op : block) {
       if (!shapeInterface)
         continue;
 
       SmallVector<ShapedTypeComponents> returnedShapes;
 
       ValueShapeRange range(op.getOperands(), operandShape);
       if (shapeInterface
               .inferReturnTypeComponents(op.getContext(), op.getLoc(), range,
-                                         op.getAttrDictionary(),
-                                         op.getRegions(), returnedShapes)
+                                         op.getAttrs(), op.getRegions(),
+                                         returnedShapes)
               .succeeded()) {
         for (auto it : llvm::zip(op.getResults(), returnedShapes)) {
           Value result = std::get<0>(it);
           ShapedTypeComponents predictedShape = std::get<1>(it);
 
           // Check whether this use case is replaceable. We define an op as
           // being replaceable if it is used by a ReturnOp or a TosaOp.
           bool replaceable = true;

mlir/lib/IR/AsmPrinter.cpp

if (region.empty())
       return;
 
     auto *entryBlock = &region.front();
     print(entryBlock, printEntryBlockArgs, printBlockTerminators);
     for (Block &b : llvm::drop_begin(region, 1))
       print(&b);
   }
 
-  void printRegionArgument(BlockArgument arg, ArrayRef<NamedAttribute> argAttrs,
+  void printRegionArgument(BlockArgument arg, AttributeRange argAttrs,
                            bool omitType) override {
     printType(arg.getType());
     // Visit the argument location.
     if (printerFlags.shouldPrintDebugInfo())
       // TODO: Allow deferring argument locations.
       initializer.visit(arg.getLoc(), /*canBeDeferred=*/false);
   }
 
   /// Consider the given type to be printed for an alias.
   void printType(Type type) override { initializer.visit(type); }
 
   /// Consider the given attribute to be printed for an alias.
   void printAttribute(Attribute attr) override { initializer.visit(attr); }
   void printAttributeWithoutType(Attribute attr) override {
     printAttribute(attr);
   }
 
   /// Print the given set of attributes with names not included within
   /// 'elidedAttrs'.
-  void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+  void printOptionalAttrDict(AttributeRange attrs,
                              ArrayRef<StringRef> elidedAttrs = {}) override {
     if (attrs.empty())
       return;
     if (elidedAttrs.empty()) {
       for (const NamedAttribute &attr : attrs)
         printAttribute(attr.second);
       return;
     }
     llvm::SmallDenseSet<StringRef> elidedAttrsSet(elidedAttrs.begin(),
                                                   elidedAttrs.end());
     for (const NamedAttribute &attr : attrs)
       if (!elidedAttrsSet.contains(attr.first.strref()))
         printAttribute(attr.second);
   }
   void printOptionalAttrDictWithKeyword(
-      ArrayRef<NamedAttribute> attrs,
-      ArrayRef<StringRef> elidedAttrs = {}) override {
+      AttributeRange attrs, ArrayRef<StringRef> elidedAttrs = {}) override {
     printOptionalAttrDict(attrs, elidedAttrs);
   }
 
   /// Return a null stream as the output stream, this will ignore any data fed
   /// to it.
   raw_ostream &getStream() const override { return os; }
 
   /// The following are hooks of `OpAsmPrinter` that are not necessary for
public:
   void printAffineMap(AffineMap map);
   void
   printAffineExpr(AffineExpr expr,
                   function_ref<void(unsigned, bool)> printValueName = nullptr);
   void printAffineConstraint(AffineExpr expr, bool isEq);
   void printIntegerSet(IntegerSet set);
 
 protected:
-  void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+  void printOptionalAttrDict(AttributeRange attrs,
                              ArrayRef<StringRef> elidedAttrs = {},
                              bool withKeyword = false);
   void printNamedAttribute(NamedAttribute attr);
   void printTrailingLocation(Location loc, bool allowAlias = true);
   void printLocationInternal(LocationAttr loc, bool pretty = false);
 
   /// Print a dense elements attribute. If 'allowHex' is true, a hex string is
   /// used instead of individual elements when the elements attr is large.
TypeSwitch<Type>(type)
         interleaveComma(tupleTy.getTypes(),
                         [&](Type type) { printType(type); });
         os << '>';
       })
       .Case<NoneType>([&](Type) { os << "none"; })
       .Default([&](Type type) { return printDialectType(type); });
 }
 
-void AsmPrinter::Impl::printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+void AsmPrinter::Impl::printOptionalAttrDict(AttributeRange attrs,
                                              ArrayRef<StringRef> elidedAttrs,
                                              bool withKeyword) {
   // If there are no attributes, then there is nothing to be done.
   if (attrs.empty())
     return;
 
   // Functor used to print a filtered attribute list.
   auto printFilteredAttributesFn = [&](auto filteredAttrs) {
void printNewline() override {
     os.indent(currentIndent);
   }
 
   /// Print a block argument in the usual format of:
   ///   %ssaName : type {attr1=42} loc("here")
   /// where location printing is controlled by the standard internal option.
   /// You may pass omitType=true to not print a type, and pass an empty
   /// attribute list if you don't care for attributes.
-  void printRegionArgument(BlockArgument arg,
-                           ArrayRef<NamedAttribute> argAttrs = {},
+  void printRegionArgument(BlockArgument arg, AttributeRange argAttrs = {},
                            bool omitType = false) override;
 
   /// Print the ID for the given value.
   void printOperand(Value value) override { printValueID(value); }
   void printOperand(Value value, raw_ostream &os) override {
     printValueID(value, /*printResultNo=*/true, &os);
   }
 
   /// Print an optional attribute dictionary with a given set of elided values.
-  void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+  void printOptionalAttrDict(AttributeRange attrs,
                              ArrayRef<StringRef> elidedAttrs = {}) override {
     Impl::printOptionalAttrDict(attrs, elidedAttrs);
   }
   void printOptionalAttrDictWithKeyword(
-      ArrayRef<NamedAttribute> attrs,
-      ArrayRef<StringRef> elidedAttrs = {}) override {
+      AttributeRange attrs, ArrayRef<StringRef> elidedAttrs = {}) override {
     Impl::printOptionalAttrDict(attrs, elidedAttrs,
                                 /*withKeyword=*/true);
   }
 
   /// Print the given successor.
   void printSuccessor(Block *successor) override;
 
   /// Print an operation successor with the operands used for the block

 }
 
 /// Print a block argument in the usual format of:
 ///   %ssaName : type {attr1=42} loc("here")
 /// where location printing is controlled by the standard internal option.
 /// You may pass omitType=true to not print a type, and pass an empty
 /// attribute list if you don't care for attributes.
 void OperationPrinter::printRegionArgument(BlockArgument arg,
-                                           ArrayRef<NamedAttribute> argAttrs,
+                                           AttributeRange argAttrs,
                                            bool omitType) {
   printOperand(arg);
   if (!omitType) {
     os << ": ";
     printType(arg.getType());
   }
   printOptionalAttrDict(argAttrs);
   // TODO: We should allow location aliases on block arguments.

mlir/lib/IR/AttributeRange.cpp

+#include "mlir/IR/AttributeRange.h"
+#include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/OperationSupport.h"
+
+using namespace mlir;
+
+AttributeRange::AttributeRange(const NamedAttrList &attrs)
+    : Base(attrs), sorted(attrs.isSorted()) {}
+
+AttributeRange::AttributeRange(DictionaryAttr attrs)
+    : AttributeRange(attrs ? attrs.getValue() : AttributeRange({}, true)) {
+  assert(!attrs ||
+         isSorted() && "expected dictionary attribute sorted flag to be true");
+}
+
+AttributeRange::AttributeRange(const detail::OpAttributeList &attrs)
+    : Base(attrs), sorted(true) {}
+
+const NamedAttribute *
+impl::detail::lookupAttributeBig(ArrayRef<NamedAttribute> attrs,
+                                 Identifier name) {
+  unsigned length = attrs.size();
+  const NamedAttribute *first = attrs.begin();
+  StringRef nameStr = name.strref();
+
+  // TODO: I wrote this binary search twice
+  while (length > 0) {
+    unsigned half = length / 2;
+    const NamedAttribute *mid = first + half;
+    auto c = mid->first.strref().compare(nameStr);
+    if (c < 0) {
+      first = mid;
+      ++first;
+      length = length - half - 1;
+    } else if (c > 0) {
+      length = half;
+    } else {
+      return mid;
+    }
+  }
+  return nullptr;
+}

mlir/lib/IR/Builders.cpp

 }
 
 UnitAttr Builder::getUnitAttr() { return UnitAttr::get(context); }
 
 BoolAttr Builder::getBoolAttr(bool value) {
   return BoolAttr::get(context, value);
 }
 
-DictionaryAttr Builder::getDictionaryAttr(ArrayRef<NamedAttribute> value) {
+DictionaryAttr Builder::getDictionaryAttr(AttributeRange value) {
   return DictionaryAttr::get(context, value);
 }
 
 IntegerAttr Builder::getIndexAttr(int64_t value) {
   return IntegerAttr::get(getIndexType(), APInt(64, value));
 }
 
 IntegerAttr Builder::getI64IntegerAttr(int64_t value) {

mlir/lib/IR/BuiltinAttributes.cpp

 // DictionaryAttr
 //===----------------------------------------------------------------------===//
 
 /// Helper function that does either an in place sort or sorts from source array
 /// into destination. If inPlace then storage is both the source and the
 /// destination, else value is the source and storage destination. Returns
 /// whether source was sorted.
 template <bool inPlace>
-static bool dictionaryAttrSort(ArrayRef<NamedAttribute> value,
+static bool dictionaryAttrSort(AttributeRange value,
                                SmallVectorImpl<NamedAttribute> &storage) {
   // Specialize for the common case.
   switch (value.size()) {
   case 0:
     // Zero already sorted.
     if (!inPlace)
       storage.clear();
     break;
if (!isSorted)
       llvm::array_pod_sort(storage.begin(), storage.end());
     return !isSorted;
   }
   return false;
 }
 
 /// Returns an entry with a duplicate name from the given sorted array of named
 /// attributes. Returns llvm::None if all elements have unique names.
-static Optional<NamedAttribute>
-findDuplicateElement(ArrayRef<NamedAttribute> value) {
+static Optional<NamedAttribute> findDuplicateElement(AttributeRange value) {
   const Optional<NamedAttribute> none{llvm::None};
   if (value.size() < 2)
     return none;
 
   if (value.size() == 2)
     return value[0].first == value[1].first ? value[0] : none;
 
   auto it = std::adjacent_find(
       value.begin(), value.end(),
       [](NamedAttribute l, NamedAttribute r) { return l.first == r.first; });
   return it != value.end() ? *it : none;
 }
 
-bool DictionaryAttr::sort(ArrayRef<NamedAttribute> value,
+bool DictionaryAttr::sort(AttributeRange value,
                           SmallVectorImpl<NamedAttribute> &storage) {
   bool isSorted = dictionaryAttrSort</*inPlace=*/false>(value, storage);
   assert(!findDuplicateElement(storage) &&
          "DictionaryAttr element names must be unique");
   return isSorted;
 }
 
 bool DictionaryAttr::sortInPlace(SmallVectorImpl<NamedAttribute> &array) {
   bool isSorted = dictionaryAttrSort</*inPlace=*/true>(array, array);
   assert(!findDuplicateElement(array) &&
          "DictionaryAttr element names must be unique");
   return isSorted;
 }
 
 Optional<NamedAttribute>
 DictionaryAttr::findDuplicate(SmallVectorImpl<NamedAttribute> &array,
                               bool isSorted) {
   if (!isSorted)
     dictionaryAttrSort</*inPlace=*/true>(array, array);
   return findDuplicateElement(array);
 }
 
-DictionaryAttr DictionaryAttr::get(MLIRContext *context,
-                                   ArrayRef<NamedAttribute> value) {
+DictionaryAttr DictionaryAttr::get(MLIRContext *context, AttributeRange value) {
   if (value.empty())
     return DictionaryAttr::getEmpty(context);
   assert(llvm::all_of(value,
                       [](const NamedAttribute &attr) { return attr.second; }) &&
          "value cannot have null entries");
 
   // We need to sort the element list to canonicalize it.
   SmallVector<NamedAttribute, 8> storage;
   if (dictionaryAttrSort</*inPlace=*/false>(value, storage))
     value = storage;
   assert(!findDuplicateElement(value) &&
          "DictionaryAttr element names must be unique");
   return Base::get(context, value);
 }
 /// Construct a dictionary with an array of values that is known to already be
 /// sorted by name and uniqued.
 DictionaryAttr DictionaryAttr::getWithSorted(MLIRContext *context,
-                                             ArrayRef<NamedAttribute> value) {
+                                             AttributeRange value) {
   if (value.empty())
     return DictionaryAttr::getEmpty(context);
   // Ensure that the attribute elements are unique and sorted.
   assert(llvm::is_sorted(value,
                          [](NamedAttribute l, NamedAttribute r) {
                            return l.first.strref() < r.first.strref();
                          }) &&
          "expected attribute values to be sorted");

 }
 Attribute DictionaryAttr::get(Identifier name) const {
   Optional<NamedAttribute> attr = getNamed(name);
   return attr ? attr->second : nullptr;
 }
 
 /// Return the specified named attribute if present, None otherwise.
 Optional<NamedAttribute> DictionaryAttr::getNamed(StringRef name) const {
-  ArrayRef<NamedAttribute> values = getValue();
-  const auto *it = llvm::lower_bound(values, name);
+  AttributeRange values = getValue();
+  auto it = llvm::lower_bound(values, name);
   return it != values.end() && it->first == name ? *it
                                                  : Optional<NamedAttribute>();
 }
 Optional<NamedAttribute> DictionaryAttr::getNamed(Identifier name) const {
   for (auto elt : getValue())
     if (elt.first == name)
       return elt;
   return llvm::None;
 }
 
 DictionaryAttr::iterator DictionaryAttr::begin() const {
-  return getValue().begin();
+  return AttributeRange(getValue()).begin();
 }
 DictionaryAttr::iterator DictionaryAttr::end() const {
-  return getValue().end();
+  return AttributeRange(getValue()).end();
 }
 size_t DictionaryAttr::size() const { return getValue().size(); }
 
 DictionaryAttr DictionaryAttr::getEmptyUnchecked(MLIRContext *context) {
-  return Base::get(context, ArrayRef<NamedAttribute>());
+  return Base::get(context, AttributeRange());
 }
 
 void DictionaryAttr::walkImmediateSubElements(
     function_ref<void(Attribute)> walkAttrsFn,
     function_ref<void(Type)> walkTypesFn) const {
   for (Attribute attr : llvm::make_second_range(getValue()))
     walkAttrsFn(attr);
 }

mlir/lib/IR/BuiltinDialect.cpp

#include "mlir/IR/BuiltinOps.cpp.inc"
   addInterfaces<BuiltinOpAsmDialectInterface>();
 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
-                      ArrayRef<NamedAttribute> attrs) {
+                      AttributeRange attrs) {
   OpBuilder builder(location->getContext());
   OperationState state(location, getOperationName());
   FuncOp::build(builder, state, name, type, attrs);
   return cast<FuncOp>(Operation::create(state));
 }
 FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
                       Operation::dialect_attr_range attrs) {
   SmallVector<NamedAttribute, 8> attrRef(attrs);
-  return create(location, name, type, llvm::makeArrayRef(attrRef));
+  return create(location, name, type, AttributeRange(attrRef));
 }
 FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
-                      ArrayRef<NamedAttribute> attrs,
-                      ArrayRef<DictionaryAttr> argAttrs) {
+                      AttributeRange attrs, ArrayRef<DictionaryAttr> argAttrs) {
   FuncOp func = create(location, name, type, attrs);
   func.setAllArgAttrs(argAttrs);
   return func;
 }
 
 void FuncOp::build(OpBuilder &builder, OperationState &state, StringRef name,
-                   FunctionType type, ArrayRef<NamedAttribute> attrs,
+                   FunctionType type, AttributeRange attrs,
                    ArrayRef<DictionaryAttr> argAttrs) {
   state.addAttribute(SymbolTable::getSymbolAttrName(),
                      builder.getStringAttr(name));
   state.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   state.attributes.append(attrs.begin(), attrs.end());
   state.addRegion();
 
   if (argAttrs.empty())

mlir/lib/IR/CMakeLists.txt

 add_mlir_library(MLIRIR
   AffineExpr.cpp
   AffineMap.cpp
   AsmPrinter.cpp
+  AttributeRange.cpp
   Attributes.cpp
   Block.cpp
   Builders.cpp
   BuiltinAttributeInterfaces.cpp
   BuiltinAttributes.cpp
   BuiltinDialect.cpp
   BuiltinTypes.cpp
   Diagnostics.cpp

mlir/lib/IR/FunctionImplementation.cpp

void mlir::function_like_impl::printFunctionSignature(
 
   p << '(';
   ArrayAttr argAttrs = op->getAttrOfType<ArrayAttr>(getArgDictAttrName());
   for (unsigned i = 0, e = argTypes.size(); i < e; ++i) {
     if (i > 0)
       p << ", ";
 
     if (!isExternal) {
-      ArrayRef<NamedAttribute> attrs;
+      AttributeRange attrs;
       if (argAttrs)
         attrs = argAttrs[i].cast<DictionaryAttr>().getValue();
       p.printRegionArgument(body.getArgument(i), attrs);
     } else {
       p.printType(argTypes[i]);
       if (argAttrs)
         p.printOptionalAttrDict(argAttrs[i].cast<DictionaryAttr>().getValue());
     }

mlir/lib/IR/Operation.cpp

OperationName OperationName::getFromOpaquePointer(const void *pointer) {
   return OperationName(
       RepresentationUnion::getFromOpaqueValue(const_cast<void *>(pointer)));
 }
 
 //===----------------------------------------------------------------------===//
 // Operation
 //===----------------------------------------------------------------------===//
 
-/// Create a new Operation with the specific fields.
-Operation *Operation::create(Location location, OperationName name,
-                             TypeRange resultTypes, ValueRange operands,
-                             ArrayRef<NamedAttribute> attributes,
-                             BlockRange successors, unsigned numRegions) {
-  return create(location, name, resultTypes, operands,
-                DictionaryAttr::get(location.getContext(), attributes),
-                successors, numRegions);
-}
-
 /// Create a new Operation from operation state.
 Operation *Operation::create(const OperationState &state) {
   return create(state.location, state.name, state.types, state.operands,
-                state.attributes.getDictionary(state.getContext()),
-                state.successors, state.regions);
+                state.attributes, state.successors, state.regions);
 }
 
 /// Create a new Operation with the specific fields.
 Operation *Operation::create(Location location, OperationName name,
                              TypeRange resultTypes, ValueRange operands,
-                             DictionaryAttr attributes, BlockRange successors,
+                             AttributeRange attributes, BlockRange successors,
                              RegionRange regions) {
   unsigned numRegions = regions.size();
   Operation *op = create(location, name, resultTypes, operands, attributes,
                          successors, numRegions);
   for (unsigned i = 0; i < numRegions; ++i)
     if (regions[i])
       op->getRegion(i).takeBody(*regions[i]);
   return op;
 }
 
-/// Overload of create that takes an existing DictionaryAttr to avoid
-/// unnecessarily uniquing a list of attributes.
+/// Create a new Operation with the specific fields.
 Operation *Operation::create(Location location, OperationName name,
                              TypeRange resultTypes, ValueRange operands,
-                             DictionaryAttr attributes, BlockRange successors,
+                             AttributeRange attributes, BlockRange successors,
                              unsigned numRegions) {
   assert(llvm::all_of(resultTypes, [](Type t) { return t; }) &&
          "unexpected null result type");
 
   // We only need to allocate additional memory for a subset of results.
   unsigned numTrailingResults = OpResult::getNumTrailing(resultTypes.size());
   unsigned numInlineResults = OpResult::getNumInline(resultTypes.size());
   unsigned numSuccessors = successors.size();
   unsigned numOperands = operands.size();
   unsigned numResults = resultTypes.size();
 
   // If the operation is known to have no operands, don't allocate an operand
   // storage.
   bool needsOperandStorage = true;
   if (operands.empty()) {
     if (const AbstractOperation *abstractOp = name.getAbstractOperation())
       needsOperandStorage = !abstractOp->hasTrait<OpTrait::ZeroOperands>();
   }
 
+  // Determine whether the attribute list is too "large" to fit inline.
+  unsigned numInlineAttrs = 0;
+  // attributes.size() <= kMaxInlineAttrs ? attributes.size() : 0;
+
   // Compute the byte size for the operation and the operand storage. This takes
   // into account the size of the operation, its trailing objects, and its
   // prefixed objects.
-  size_t byteSize =
-      totalSizeToAlloc<BlockOperand, Region, detail::OperandStorage>(
-          numSuccessors, numRegions, needsOperandStorage ? 1 : 0) +
+  size_t byteSize = totalSizeToAlloc<BlockOperand, Region, NamedAttribute,
+                                     detail::OperandStorage>(
+                        numSuccessors, numRegions, numInlineAttrs,
+                        needsOperandStorage ? 1 : 0) +
                     detail::OperandStorage::additionalAllocSize(numOperands);
   size_t prefixByteSize = llvm::alignTo(
       Operation::prefixAllocSize(numTrailingResults, numInlineResults),
       alignof(Operation));
   char *mallocMem = reinterpret_cast<char *>(malloc(byteSize + prefixByteSize));
   void *rawMem = mallocMem + prefixByteSize;
 
   // Create the new Operation.
-  Operation *op =
-      ::new (rawMem) Operation(location, name, numResults, numSuccessors,
-                               numRegions, attributes, needsOperandStorage);
+  Operation *op = ::new (rawMem)
+      Operation(location, name, numResults, numSuccessors, numRegions,
+                numInlineAttrs, attributes, needsOperandStorage);
 
   assert((numSuccessors == 0 || op->mightHaveTrait<OpTrait::IsTerminator>()) &&
          "unexpected successors in a non-terminator operation");
 
   // Initialize the results.
   auto resultTypeIt = resultTypes.begin();
   for (unsigned i = 0; i < numInlineResults; ++i, ++resultTypeIt)
     new (op->getInlineOpResult(i)) detail::InlineOpResult(*resultTypeIt, i);
Operation *Operation::create(Location location, OperationName name,
   for (unsigned i = 0; i != numSuccessors; ++i)
     new (&blockOperands[i]) BlockOperand(op, successors[i]);
 
   return op;
 }
 
 Operation::Operation(Location location, OperationName name, unsigned numResults,
                      unsigned numSuccessors, unsigned numRegions,
-                     DictionaryAttr attributes, bool hasOperandStorage)
+                     unsigned numInlineAttributes, AttributeRange attributes,
+                     bool hasOperandStorage)
     : location(location), numResults(numResults), numSuccs(numSuccessors),
-      numRegions(numRegions), hasOperandStorage(hasOperandStorage), name(name),
-      attrs(attributes) {
-  assert(attributes && "unexpected null attribute dictionary");
+      numRegions(numRegions), numInlineAttrs(numInlineAttributes),
+      hasOperandStorage(hasOperandStorage), name(name),
+      attrs(getInlineAttrStorage(), attributes) {
 #ifndef NDEBUG
   if (!getDialect() && !getContext()->allowsUnregisteredDialects())
     llvm::report_fatal_error(
         name.getStringRef() +
         " created with unregistered dialect. If this is intended, please call "
         "allowUnregisteredDialects() on the MLIRContext, or use "
         "-allow-unregistered-dialect with the MLIR tool used.");
 #endif

 }
 
 LogicalResult OpTrait::impl::verifyNoRegionArguments(Operation *op) {
   for (Region &region : op->getRegions()) {
     if (region.empty())
       continue;
 
     if (region.getNumArguments() != 0) {
-      if (op->getNumRegions() > 1)
+      if (op->getNumRegions() > 1) {
         return op->emitOpError("region #")
                << region.getRegionNumber() << " should have no arguments";
-      else
-        return op->emitOpError("region should have no arguments");
+      }
     }
   }
   return success();
 }
 
 LogicalResult OpTrait::impl::verifyElementwise(Operation *op) {
   auto isMappableType = [](Type type) {
     return type.isa<VectorType, TensorType>();

mlir/lib/IR/OperationSupport.cpp

 #include <numeric>
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // NamedAttrList
 //===----------------------------------------------------------------------===//
 
-NamedAttrList::NamedAttrList(ArrayRef<NamedAttribute> attributes) {
-  assign(attributes.begin(), attributes.end());
-}
+NamedAttrList::NamedAttrList(AttributeRange attributes) { assign(attributes); }
 
 NamedAttrList::NamedAttrList(DictionaryAttr attributes)
-    : NamedAttrList(attributes ? attributes.getValue()
-                               : ArrayRef<NamedAttribute>()) {
+    : NamedAttrList(attributes ? attributes.getValue() : AttributeRange()) {
   dictionarySorted.setPointerAndInt(attributes, true);
 }
 
 NamedAttrList::NamedAttrList(const_iterator in_start, const_iterator in_end) {
   assign(in_start, in_end);
 }
 
-ArrayRef<NamedAttribute> NamedAttrList::getAttrs() const { return attrs; }
+AttributeRange NamedAttrList::getAttrs() const { return attrs; }
 
 Optional<NamedAttribute> NamedAttrList::findDuplicate() const {
   Optional<NamedAttribute> duplicate =
       DictionaryAttr::findDuplicate(attrs, isSorted());
   // DictionaryAttr::findDuplicate will sort the list, so reset the sorted
   // state.
   if (!isSorted())
     dictionarySorted.setPointerAndInt(nullptr, true);

 NamedAttrList::operator=(const SmallVectorImpl<NamedAttribute> &rhs) {
   assign(rhs.begin(), rhs.end());
   return *this;
 }
 
 NamedAttrList::operator ArrayRef<NamedAttribute>() const { return attrs; }
 
 //===----------------------------------------------------------------------===//
+// OpAttributeList
+//===----------------------------------------------------------------------===//
+
+detail::OpAttributeList::OpAttributeList(
+    MutableArrayRef<NamedAttribute> initialStorage, AttributeRange attributes)
+    : attrs(/*initialStorage, */ attributes.begin(), attributes.end()) {
+  assert(llvm::none_of(attributes,
+                       [](NamedAttribute attr) { return !attr.second; }) &&
+         "cannot have null attributes");
+  // TODO: llvm::array_pod_sort calls `qsort` which is somehow making heap
+  // allocations...?
+  if (!attributes.isSorted())
+    std::sort(attrs.begin(), attrs.end());
+}
+
+void detail::OpAttributeList::set(StringRef name, Attribute value) {
+  assert(value && "attribute cannot be null");
+  auto it = lookupAttribute(name);
+  if (it.second) {
+    it.first->second = value;
+  } else {
+    attrs.insert(it.first, {Identifier::get(name, value.getContext()), value});
+  }
+}
+
+void detail::OpAttributeList::set(Identifier name, Attribute value,
+                                  unsigned left, unsigned right) {
+  assert(value && "attribute cannot be null");
+  auto it = lookupAttribute(name, left, right);
+  if (it.second) {
+    it.first->second = value;
+  } else {
+    // Need to perform a string lookup to do a sorted insert.
+    auto insertIt = lookupAttribute(name.strref());
+    assert(!insertIt.second);
+    attrs.insert(insertIt.first, {name, value});
+  }
+}
+
+void detail::OpAttributeList::addOrSet(Identifier name, Attribute value) {
+  assert(value && "attribute cannot be null");
+  // Go straight to string lookup.
+  auto it = lookupAttribute(name.strref());
+  if (LLVM_UNLIKELY(it.second)) {
+    it.first->second = value;
+  } else {
+    attrs.insert(it.first, {name, value});
+  }
+}
+
+void detail::OpAttributeList::setOrAdd(StringRef name, Attribute value) {
+  assert(value && "attribute cannot be null");
+  // Go straight to identifier lookup.
+  auto nameId = Identifier::get(name, value.getContext());
+  auto it = lookupAttribute(nameId);
+  if (LLVM_LIKELY(it.second)) {
+    it.first->second = value;
+  } else {
+    // Need to perform a string lookup to do a sorted insert.
+    auto insertIt = lookupAttribute(name);
+    assert(!insertIt.second);
+    attrs.insert(insertIt.first, {nameId, value});
+  }
+}
+
+void detail::OpAttributeList::definitelySet(Identifier name, Attribute value,
+                                            unsigned left, unsigned right) {
+  auto it = lookupAttribute(name, left, right);
+  assert(it.second && "attribute to set not found");
+  it.first->second = value;
+}
+
+void detail::OpAttributeList::assign(AttributeRange attributes) {
+  assert(llvm::none_of(attributes,
+                       [](NamedAttribute attr) { return !attr.second; }) &&
+         "cannot have null attributes");
+  // Re-using the existing storage may prevent a re-allocation.
+  attrs.assign(attributes.begin(), attributes.end());
+  if (!attributes.isSorted())
+    std::sort(attrs.begin(), attrs.end());
+}
+
+DictionaryAttr
+detail::OpAttributeList::convertToDictionary(MLIRContext *context) const {
+  return DictionaryAttr::getWithSorted(context,
+                                       ArrayRef<NamedAttribute>(attrs));
+}
+
+//===----------------------------------------------------------------------===//
 // OperationState
 //===----------------------------------------------------------------------===//
 
 OperationState::OperationState(Location location, StringRef name)
     : location(location), name(name, location->getContext()) {}
 
 OperationState::OperationState(Location location, OperationName name)
     : location(location), name(name) {}
 
 OperationState::OperationState(Location location, StringRef name,
                                ValueRange operands, TypeRange types,
-                               ArrayRef<NamedAttribute> attributes,
-                               BlockRange successors,
+                               AttributeRange attributes, BlockRange successors,
                                MutableArrayRef<std::unique_ptr<Region>> regions)
     : location(location), name(name, location->getContext()),
       operands(operands.begin(), operands.end()),
       types(types.begin(), types.end()),
       attributes(attributes.begin(), attributes.end()),
       successors(successors.begin(), successors.end()) {
   for (std::unique_ptr<Region> &r : regions)
     this->regions.push_back(std::move(r));

 
 llvm::hash_code OperationEquivalence::computeHash(
     Operation *op, function_ref<llvm::hash_code(Value)> hashOperands,
     function_ref<llvm::hash_code(Value)> hashResults, Flags flags) {
   // Hash operations based upon their:
   //   - Operation Name
   //   - Attributes
   //   - Result Types
-  llvm::hash_code hash = llvm::hash_combine(
-      op->getName(), op->getAttrDictionary(), op->getResultTypes());
+  llvm::hash_code hash =
+      llvm::hash_combine(op->getName(), op->getAttrs(), op->getResultTypes());
 
   //   - Operands
   for (Value operand : op->getOperands())
     hash = llvm::hash_combine(hash, hashOperands(operand));
   //   - Operands
   for (Value result : op->getResults())
     hash = llvm::hash_combine(hash, hashResults(result));
   return hash;

 bool OperationEquivalence::isEquivalentTo(
     Operation *lhs, Operation *rhs,
     function_ref<LogicalResult(Value, Value)> mapOperands,
     function_ref<LogicalResult(Value, Value)> mapResults, Flags flags) {
   if (lhs == rhs)
     return true;
 
   // Compare the operation properties.
-  if (lhs->getName() != rhs->getName() ||
-      lhs->getAttrDictionary() != rhs->getAttrDictionary() ||
+  if (lhs->getName() != rhs->getName() || lhs->getAttrs() != rhs->getAttrs() ||
       lhs->getNumRegions() != rhs->getNumRegions() ||
       lhs->getNumSuccessors() != rhs->getNumSuccessors() ||
       lhs->getNumOperands() != rhs->getNumOperands() ||
       lhs->getNumResults() != rhs->getNumResults())
     return false;
   if (!(flags & IgnoreLocations) && lhs->getLoc() != rhs->getLoc())
     return false;
 

mlir/lib/IR/SymbolTable.cpp

LogicalResult detail::verifySymbol(Operation *op) {
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Symbol Use Lists
 //===----------------------------------------------------------------------===//
 
+/// Abstraction of an attribute container. An attribute container can be the
+/// operation itself, a dictionary attribute, or an array attribute.
+using AttrContainer = llvm::PointerUnion<Operation *, Attribute>;
+
 /// Walk all of the symbol references within the given operation, invoking the
 /// provided callback for each found use. The callbacks takes as arguments: the
 /// use of the symbol, and the nested access chain to the attribute within the
 /// operation dictionary. An access chain is a set of indices into nested
 /// container attributes. For example, a symbol use in an attribute dictionary
 /// that looks like the following:
 ///
 ///    {use = [{other_attr, @symbol}]}
 ///
 /// May have the following access chain:
 ///
 ///     [0, 0, 1]
 ///
 static WalkResult walkSymbolRefs(
     Operation *op,
     function_ref<WalkResult(SymbolTable::SymbolUse, ArrayRef<int>)> callback) {
   // Check to see if the operation has any attributes.
-  DictionaryAttr attrDict = op->getAttrDictionary();
-  if (attrDict.empty())
+  AttributeRange attrs = op->getAttrs();
+  if (attrs.empty())
     return WalkResult::advance();
 
   // A worklist of a container attribute and the current index into the held
-  // attribute list.
-  SmallVector<Attribute, 1> attrWorklist(1, attrDict);
+  // attribute list. The first container of attributes is always the operation
+  // itself.
+  SmallVector<AttrContainer, 1> attrWorklist(1, op);
   SmallVector<int, 1> curAccessChain(1, /*Value=*/-1);
 
   // Process the symbol references within the given nested attribute range.
   auto processAttrs = [&](int &index, auto attrRange) -> WalkResult {
     for (Attribute attr : llvm::drop_begin(attrRange, index)) {
       /// Check for a nested container attribute, these will also need to be
       /// walked.
       if (attr.isa<ArrayAttr, DictionaryAttr>()) {
auto processAttrs = [&](int &index, auto attrRange) -> WalkResult {
     // Pop this container attribute from the worklist.
     attrWorklist.pop_back();
     curAccessChain.pop_back();
     return WalkResult::advance();
   };
 
   WalkResult result = WalkResult::advance();
   do {
-    Attribute attr = attrWorklist.back();
+    AttrContainer container = attrWorklist.back();
     int &index = curAccessChain.back();
     ++index;
 
     // Process the given attribute, which is guaranteed to be a container.
-    if (auto dict = attr.dyn_cast<DictionaryAttr>())
-      result = processAttrs(index, make_second_range(dict.getValue()));
-    else
+    if (auto attr = container.dyn_cast<Attribute>()) {
+      if (auto dictAttr = attr.dyn_cast<DictionaryAttr>()) {
+        result =
+            processAttrs(index, llvm::make_second_range(dictAttr.getValue()));
+      } else {
         result = processAttrs(index, attr.cast<ArrayAttr>().getValue());
+      }
+    } else {
+      result = processAttrs(
+          index,
+          llvm::make_second_range(container.get<Operation *>()->getAttrs()));
+    }
   } while (!attrWorklist.empty() && !result.wasInterrupted());
   return result;
 }
 
 /// Walk all of the uses, for any symbol, that are nested within the given
 /// regions, invoking the provided callback for each. This does not traverse
 /// into any nested symbol tables.
 static Optional<WalkResult> walkSymbolUses(
bool SymbolTable::symbolKnownUseEmpty(Operation *symbol, Region *from) {
   return symbolKnownUseEmptyImpl(symbol, from);
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolTable::replaceAllSymbolUses
 
 /// Rebuild the given attribute container after replacing all references to a
 /// symbol with the updated attribute in 'accesses'.
-static Attribute rebuildAttrAfterRAUW(
-    Attribute container,
+static AttrContainer rebuildAttrAfterRAUW(
+    AttrContainer container,
     ArrayRef<std::pair<SmallVector<int, 1>, SymbolRefAttr>> accesses,
     unsigned depth) {
   // Given a range of Attributes, update the ones referred to by the given
   // access chains to point to the new symbol attribute.
   auto updateAttrs = [&](auto &&attrRange) {
     auto attrBegin = std::begin(attrRange);
     for (unsigned i = 0, e = accesses.size(); i != e;) {
       ArrayRef<int> access = accesses[i].first;
for (unsigned i = 0, e = accesses.size(); i != e;) {
       // Otherwise, this is a container. Collect all of the accesses for this
       // index and recurse. The recursion here is bounded by the size of the
       // largest access array.
       auto nestedAccesses = accesses.drop_front(i).take_while([&](auto &it) {
         ArrayRef<int> nextAccess = it.first;
         return nextAccess.size() > depth + 1 &&
                nextAccess[depth] == access[depth];
       });
-      attr = rebuildAttrAfterRAUW(attr, nestedAccesses, depth + 1);
+      AttrContainer result =
+          rebuildAttrAfterRAUW(attr, nestedAccesses, depth + 1);
+      assert(result.is<Attribute>() &&
+             "expected nested container to be an attribute");
+      attr = result.get<Attribute>();
 
       // Skip over all of the accesses that refer to the nested container.
       i += nestedAccesses.size();
     }
   };
 
-  if (auto dictAttr = container.dyn_cast<DictionaryAttr>()) {
+  if (auto attr = container.dyn_cast<Attribute>()) {
+    if (auto dictAttr = attr.dyn_cast<DictionaryAttr>()) {
       auto newAttrs = llvm::to_vector<4>(dictAttr.getValue());
       updateAttrs(make_second_range(newAttrs));
       return DictionaryAttr::get(dictAttr.getContext(), newAttrs);
     }
-  auto newAttrs = llvm::to_vector<4>(container.cast<ArrayAttr>().getValue());
+    auto newAttrs = llvm::to_vector<4>(attr.cast<ArrayAttr>().getValue());
     updateAttrs(newAttrs);
-  return ArrayAttr::get(container.getContext(), newAttrs);
+    return ArrayAttr::get(attr.getContext(), newAttrs);
+  }
+  auto *op = container.get<Operation *>();
+  auto opAttrs = llvm::to_vector<4>(op->getAttrs());
+  updateAttrs(make_second_range(opAttrs));
+  op->setAttrs(AttributeRange(opAttrs, /*sorted=*/true));
+  return op;
 }
 
 /// Generates a new symbol reference attribute with a new leaf reference.
 static SymbolRefAttr generateNewRefAttr(SymbolRefAttr oldAttr,
                                         FlatSymbolRefAttr newLeafAttr) {
   if (oldAttr.isa<FlatSymbolRefAttr>())
     return newLeafAttr;
   auto nestedRefs = llvm::to_vector<2>(oldAttr.getNestedReferences());
   nestedRefs.back() = newLeafAttr;
   return SymbolRefAttr::get(oldAttr.getRootReference(), nestedRefs);
 }
 
 /// The implementation of SymbolTable::replaceAllSymbolUses below.
 template <typename SymbolT, typename IRUnitT>
 static LogicalResult
 replaceAllSymbolUsesImpl(SymbolT symbol, StringAttr newSymbol, IRUnitT *limit) {
-  // A collection of operations along with their new attribute dictionary.
-  std::vector<std::pair<Operation *, DictionaryAttr>> updatedAttrDicts;
-
   // The current operation being processed.
   Operation *curOp = nullptr;
 
   // The set of access chains into the attribute dictionary of the current
   // operation, as well as the replacement attribute to use.
   SmallVector<std::pair<SmallVector<int, 1>, SymbolRefAttr>, 1> accessChains;
 
   // Generate a new attribute dictionary for the current operation by replacing
   // references to the old symbol.
-  auto generateNewAttrDict = [&] {
-    auto oldDict = curOp->getAttrDictionary();
-    auto newDict = rebuildAttrAfterRAUW(oldDict, accessChains, /*depth=*/0);
-    return newDict.cast<DictionaryAttr>();
+  auto updateOpAttrs = [&](Operation *op) {
+    rebuildAttrAfterRAUW(op, accessChains, /*depth=*/0);
   };
 
   // Generate a new attribute to replace the given attribute.
   FlatSymbolRefAttr newLeafAttr = FlatSymbolRefAttr::get(newSymbol);
   for (SymbolScope &scope : collectSymbolScopes(symbol, limit)) {
     SymbolRefAttr newAttr = generateNewRefAttr(scope.symbol, newLeafAttr);
     auto walkFn = [&](SymbolTable::SymbolUse symbolUse,
                       ArrayRef<int> accessChain) {
auto walkFn = [&](SymbolTable::SymbolUse symbolUse,
               SymbolRefAttr::get(useRef.getRootReference(), nestedRefs);
         }
       }
 
       // If there was a previous operation, generate a new attribute dict
       // for it. This means that we've finished processing the current
       // operation, so generate a new dictionary for it.
       if (curOp && symbolUse.getUser() != curOp) {
-        updatedAttrDicts.push_back({curOp, generateNewAttrDict()});
+        updateOpAttrs(curOp);
         accessChains.clear();
       }
 
       // Record this access.
       curOp = symbolUse.getUser();
       accessChains.push_back({llvm::to_vector<1>(accessChain), replacementRef});
       return WalkResult::advance();
     };
     if (!scope.walk(walkFn))
       return failure();
 
     // Check to see if we have a dangling op that needs to be processed.
     if (curOp) {
-      updatedAttrDicts.push_back({curOp, generateNewAttrDict()});
+      updateOpAttrs(curOp);
       curOp = nullptr;
     }
   }
 
-  // Update the attribute dictionaries as necessary.
-  for (auto &it : updatedAttrDicts)
-    it.first->setAttrs(it.second);
   return success();
 }
 
 /// Attempt to replace all uses of the given symbol 'oldSymbol' with the
 /// provided symbol 'newSymbol' that are nested within the given operation
 /// 'from'. This does not traverse into any nested symbol tables. If there are
 /// any unknown operations that may potentially be symbol tables, no uses are
 /// replaced and failure is returned.

mlir/lib/Interfaces/InferTypeOpInterface.cpp

ShapeAdaptor ValueShapeRange::getShape(int index) const {
   if (index < 0 || static_cast<size_t>(index) >= size())
     return nullptr;
   return getShape(operator[](index));
 }
 
 LogicalResult mlir::detail::inferReturnTensorTypes(
     function_ref<LogicalResult(
         MLIRContext *, Optional<Location> location, ValueShapeRange operands,
-        DictionaryAttr attributes, RegionRange regions,
+        AttributeRange attributes, RegionRange regions,
         SmallVectorImpl<ShapedTypeComponents> &retComponents)>
         componentTypeFn,
     MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   SmallVector<ShapedTypeComponents, 2> retComponents;
   if (failed(componentTypeFn(context, location, operands, attributes, regions,
                              retComponents)))
     return failure();
   for (auto shapeAndType : retComponents) {
     assert(shapeAndType.getAttribute() == nullptr && "attribute not supported");
     if (shapeAndType.hasRank())
       inferredReturnTypes.push_back(RankedTensorType::get(
           shapeAndType.getDims(), shapeAndType.getElementType()));
     else
       inferredReturnTypes.push_back(
           UnrankedTensorType::get(shapeAndType.getElementType()));
   }
   return success();
 }
 
 LogicalResult mlir::detail::verifyInferredResultTypes(Operation *op) {
   SmallVector<Type, 4> inferredReturnTypes;
   auto retTypeFn = cast<InferTypeOpInterface>(op);
-  if (failed(retTypeFn.inferReturnTypes(
-          op->getContext(), op->getLoc(), op->getOperands(),
-          op->getAttrDictionary(), op->getRegions(), inferredReturnTypes)))
+  if (failed(retTypeFn.inferReturnTypes(op->getContext(), op->getLoc(),
+                                        op->getOperands(), op->getAttrs(),
+                                        op->getRegions(), inferredReturnTypes)))
     return failure();
   if (!retTypeFn.isCompatibleReturnTypes(inferredReturnTypes,
                                          op->getResultTypes()))
     return op->emitOpError("inferred type(s) ")
            << inferredReturnTypes
            << " are incompatible with return type(s) of operation "
            << op->getResultTypes();
   return success();
 }

mlir/lib/Pass/IRPrinting.cpp

public:
   OperationFingerPrint(Operation *topOp) {
     llvm::SHA1 hasher;
 
     // Hash each of the operations based upon their mutable bits:
     topOp->walk([&](Operation *op) {
       //   - Operation pointer
       addDataToHash(hasher, op);
       //   - Attributes
-      addDataToHash(hasher, op->getAttrDictionary());
+      for (NamedAttribute attr : op->getAttrs()) {
+        addDataToHash(hasher, attr.first);
+        addDataToHash(hasher, attr.second);
+      }
       //   - Blocks in Regions
       for (Region &region : op->getRegions()) {
         for (Block &block : region) {
           addDataToHash(hasher, &block);
           for (BlockArgument arg : block.getArguments())
             addDataToHash(hasher, arg);
         }
       }

mlir/lib/Rewrite/ByteCode.cpp

for (unsigned i = 0, e = read(); i != e; ++i) {
     }
 
     // Handle the case where the operation has inferred types.
     InferTypeOpInterface::Concept *concept =
         state.name.getAbstractOperation()->getInterface<InferTypeOpInterface>();
 
     // TODO: Handle failure.
     state.types.clear();
-    if (failed(concept->inferReturnTypes(
-            state.getContext(), state.location, state.operands,
-            state.attributes.getDictionary(state.getContext()), state.regions,
-            state.types)))
+    if (failed(concept->inferReturnTypes(state.getContext(), state.location,
+                                         state.operands, state.attributes,
+                                         state.regions, state.types)))
       return;
     break;
   }
 
   Operation *resultOp = rewriter.createOperation(state);
   memory[memIndex] = resultOp;
 
   LLVM_DEBUG({

mlir/lib/Transforms/SCCP.cpp

SmallVector<Attribute> constantOperands(
         llvm::map_range(operands, [](LatticeElement<SCCPLatticeValue> *value) {
           return value->getValue().constant;
         }));
 
     // Save the original operands and attributes just in case the operation
     // folds in-place. The constant passed in may not correspond to the real
     // runtime value, so in-place updates are not allowed.
     SmallVector<Value, 8> originalOperands(op->getOperands());
-    DictionaryAttr originalAttrs = op->getAttrDictionary();
+    SmallVector<NamedAttribute> originalAttrs = op->getAttrs().toVector();
 
     // Simulate the result of folding this operation to a constant. If folding
     // fails or was an in-place fold, mark the results as overdefined.
     SmallVector<OpFoldResult, 8> foldResults;
     foldResults.reserve(op->getNumResults());
     if (failed(op->fold(constantOperands, foldResults)))
       return markAllPessimisticFixpoint(op->getResults());
 

mlir/lib/Transforms/Utils/DialectConversion.cpp

 
 /// The state of an operation that was updated by a pattern in-place. This
 /// contains all of the necessary information to reconstruct an operation that
 /// was updated in place.
 class OperationTransactionState {
 public:
   OperationTransactionState() = default;
   OperationTransactionState(Operation *op)
-      : op(op), loc(op->getLoc()), attrs(op->getAttrDictionary()),
+      : op(op), loc(op->getLoc()), attrs(op->getAttrs().toVector()),
         operands(op->operand_begin(), op->operand_end()),
         successors(op->successor_begin(), op->successor_end()) {}
 
   /// Discard the transaction state and reset the state of the original
   /// operation.
   void resetOperation() const {
     op->setLoc(loc);
     op->setAttrs(attrs);
     op->setOperands(operands);
     for (auto it : llvm::enumerate(successors))
       op->setSuccessor(it.value(), it.index());
   }
 
   /// Return the original operation of this state.
   Operation *getOperation() const { return op; }
 
 private:
   Operation *op;
   LocationAttr loc;
-  DictionaryAttr attrs;
+  SmallVector<NamedAttribute> attrs;
   SmallVector<Value, 8> operands;
   SmallVector<Block *, 2> successors;
 };
 
 //===----------------------------------------------------------------------===//
 // OpReplacement
 
 /// This class represents one requested operation replacement via 'replaceOp' or

mlir/test/lib/Dialect/Test/TestDialect.cpp

static void printCustomDirectiveAttributes(OpAsmPrinter &printer, Operation *,
                                            Attribute attribute,
                                            Attribute optAttribute) {
   printer << attribute;
   if (optAttribute)
     printer << ", " << optAttribute;
 }
 
 static void printCustomDirectiveAttrDict(OpAsmPrinter &printer, Operation *op,
-                                         DictionaryAttr attrs) {
-  printer.printOptionalAttrDict(attrs.getValue());
+                                         AttributeRange attrs) {
+  printer.printOptionalAttrDict(attrs);
 }
 
 static void printCustomDirectiveOptionalOperandRef(OpAsmPrinter &printer,
                                                    Operation *op,
                                                    Value optOperand) {
   printer << (optOperand ? "1" : "0");
 }
 

 }
 
 OpFoldResult TestPassthroughFold::fold(ArrayRef<Attribute> operands) {
   return getOperand();
 }
 
 LogicalResult OpWithInferTypeInterfaceOp::inferReturnTypes(
     MLIRContext *, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() != operands[1].getType()) {
     return emitOptionalError(location, "operand type mismatch ",
                              operands[0].getType(), " vs ",
                              operands[1].getType());
   }
   inferredReturnTypes.assign({operands[0].getType()});
   return success();
 }
 
 LogicalResult OpWithShapedTypeInferTypeInterfaceOp::inferReturnTypeComponents(
     MLIRContext *context, Optional<Location> location, ValueShapeRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    AttributeRange attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   // Create return type consisting of the last element of the first operand.
   auto operandType = operands.front().getType();
   auto sval = operandType.dyn_cast<ShapedType>();
   if (!sval) {
     return emitOptionalError(location, "only shaped type operands allowed");
   }
   int64_t dim =

mlir/test/lib/Dialect/Test/TestOps.td

 
 def FormatInferTypeOp : TEST_Op<"format_infer_type", [InferTypeOpInterface]> {
   let results = (outs AnyType);
   let assemblyFormat = "attr-dict";
 
   let extraClassDeclaration = [{
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
           ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-          ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+          ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
           ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
       inferredReturnTypes.assign({::mlir::IntegerType::get(context, 16)});
       return ::mlir::success();
     }
    }];
 }
 
 //===----------------------------------------------------------------------===//

 def TableGenBuildOp5 : TEST_Op<"tblgen_build_5",
       [SameOperandsAndResultType, InferTypeOpInterface]> {
   let arguments = (ins Variadic<AnyType>:$inputs);
   let results = (outs AnyType:$result);
 
   let extraClassDeclaration = [{
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *,
           ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
-          ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+          ::mlir::AttributeRange attributes, ::mlir::RegionRange regions,
           ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
       inferredReturnTypes.assign({operands[0].getType()});
       return ::mlir::success();
     }
    }];
 }
 
 //===----------------------------------------------------------------------===//

mlir/test/lib/Dialect/Test/TestPatterns.cpp

static void invokeCreateWithInferredReturnType(Operation *op) {
   b.setInsertionPointAfter(op);
 
   // Use permutations of 2 args as operands.
   assert(fop.getNumArguments() >= 2);
   for (int i = 0, e = fop.getNumArguments(); i < e; ++i) {
     for (int j = 0; j < e; ++j) {
       std::array<Value, 2> values = {{fop.getArgument(i), fop.getArgument(j)}};
       SmallVector<Type, 2> inferredReturnTypes;
-      if (succeeded(OpTy::inferReturnTypes(
-              context, llvm::None, values, op->getAttrDictionary(),
-              op->getRegions(), inferredReturnTypes))) {
+      if (succeeded(OpTy::inferReturnTypes(context, llvm::None, values,
+                                           op->getAttrs(), op->getRegions(),
+                                           inferredReturnTypes))) {
         OperationState state(location, OpTy::getOperationName());
         // TODO: Expand to regions.
         OpTy::build(b, state, values, op->getAttrs());
         (void)b.createOperation(state);
       }
     }
   }
 }

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-yaml-gen.yaml

 
 #       ODS:  let arguments =
 #  ODS-NEXT:    Variadic<AnyType>:$inputs,
 #  ODS-NEXT:    Variadic<AnyShaped>:$outputs
 
 #       ODS:  let builders =
 #       ODS:  (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
 #  ODS-NEXT:       "ValueRange":$outputs,
-#  ODS-NEXT:       CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
+#  ODS-NEXT:       CArg<"AttributeRange", "{}">:$attributes),
 
 #       ODS:    $_state.addOperands(inputs);
 #  ODS-NEXT:    $_state.addOperands(outputs);
 #  ODS-NEXT:    $_state.addTypes(resultTensorTypes);
 #  ODS-NEXT:    $_state.addAttributes(attributes);
 #  ODS-NEXT:    $_state.addAttribute(
 #  ODS-NEXT:      "operand_segment_sizes",
 #  ODS-NEXT:      $_builder.getI32VectorAttr({

mlir/test/mlir-tblgen/op-attribute.td

 // DEF:        if (cAttr) {
 // DEF-NEXT:     odsState.addAttribute(cAttrAttrName(odsState.name), cAttr);
 
 // DEF:      void AOp::build(
 // DEF:        some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr
 // DEF:        odsState.addAttribute(aAttrAttrName(odsState.name), some-const-builder-call(odsBuilder, aAttr));
 
 // DEF:      void AOp::build(
-// DEF:        ::llvm::ArrayRef<::mlir::NamedAttribute> attributes
+// DEF:        ::mlir::AttributeRange attributes
 // DEF:      odsState.addAttributes(attributes);
 
 // Test the above but with prefix.
 
 def Test2_Dialect : Dialect {
   let name = "test2";
   let cppNamespace = "foobar2";
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;

 // DEF:        if (cAttr) {
 // DEF-NEXT:     odsState.addAttribute(getCAttrAttrName(odsState.name), cAttr);
 
 // DEF:      void AgetOp::build(
 // DEF:        some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr
 // DEF:        odsState.addAttribute(getAAttrAttrName(odsState.name), some-const-builder-call(odsBuilder, aAttr));
 
 // DEF:      void AgetOp::build(
-// DEF:        ::llvm::ArrayRef<::mlir::NamedAttribute> attributes
+// DEF:        ::mlir::AttributeRange attributes
 // DEF:      odsState.addAttributes(attributes);
 
 def SomeTypeAttr : TypeAttrBase<"SomeType", "some type attribute">;
 
 def BOp : NS_Op<"b_op", []> {
   let arguments = (ins
     AnyAttr:$any_attr,
     BoolAttr:$bool_attr,

mlir/test/mlir-tblgen/op-decl-and-defs.td

let extraClassDeclaration = [{
     void displayGraph();
   }];
 }
 
 // CHECK-LABEL: NS::AOp declarations
 
 // CHECK: class AOpAdaptor {
 // CHECK: public:
-// CHECK:   AOpAdaptor(::mlir::ValueRange values
+// CHECK:   AOpAdaptor(::mlir::MLIRContext *mlirContext
 // CHECK:   ::mlir::ValueRange getODSOperands(unsigned index);
 // CHECK:   ::mlir::Value getA();
 // CHECK:   ::mlir::ValueRange getB();
 // CHECK:   ::mlir::IntegerAttr getAttr1();
 // CHECK:   ::mlir::FloatAttr getAttr2();
 // CHECK:   ::mlir::Region &getSomeRegion();
 // CHECK:   ::mlir::RegionRange getSomeRegions();
 // CHECK: private:

 // CHECK:   uint32_t getAttr1();
 // CHECK:   ::mlir::FloatAttr getAttr2Attr()
 // CHECK:   ::llvm::Optional< ::llvm::APFloat > getAttr2();
 // CHECK:   ::mlir::Attribute removeAttr2Attr();
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value val);
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, int integer = 0);
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::TypeRange s, ::mlir::Value a, ::mlir::ValueRange b, ::mlir::IntegerAttr attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::TypeRange s, ::mlir::Value a, ::mlir::ValueRange b, uint32_t attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
-// CHECK:   static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes, unsigned numRegions)
+// CHECK:   static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes, unsigned numRegions)
 // CHECK:   static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
 // CHECK:   void print(::mlir::OpAsmPrinter &p);
 // CHECK:   ::mlir::LogicalResult verify();
 // CHECK:   static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
 // CHECK:   ::mlir::LogicalResult fold(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::OpFoldResult> &results);
 // CHECK:   // Display a graph for debugging purposes.
 // CHECK:   void displayGraph();
 // CHECK: };
 
 // DEFS-LABEL: NS::AOp definitions
 
-// DEFS: AOpAdaptor::AOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions)
+// DEFS: AOpAdaptor::AOpAdaptor(::mlir::MLIRContext *mlirContext, ::mlir::ValueRange values, ::mlir::AttributeRange attrs, ::mlir::RegionRange regions) : odsContext(mlirContext), odsOperands(values), odsAttrs(attrs), odsRegions(regions)
 // DEFS: ::mlir::RegionRange AOpAdaptor::getRegions()
 // DEFS: ::mlir::RegionRange AOpAdaptor::getSomeRegions()
 // DEFS-NEXT: return odsRegions.drop_front(1);
 
 // Check AttrSizedOperandSegments
 // ---
 
 def NS_AttrSizedOperandOp : NS_Op<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
   let arguments = (ins
     Variadic<I32>:$a,
     Variadic<I32>:$b,
     I32:$c,
     Variadic<I32>:$d,
     I32ElementsAttr:$operand_segment_sizes
   );
 }
 
 // CHECK-LABEL: AttrSizedOperandOpAdaptor(
+// CHECK-SAME:    ::mlir::MLIRContext *mlirContext
 // CHECK-SAME:    ::mlir::ValueRange values
-// CHECK-SAME:    ::mlir::DictionaryAttr attrs
+// CHECK-SAME:    ::mlir::AttributeRange attrs
 // CHECK:  ::mlir::ValueRange getA();
 // CHECK:  ::mlir::ValueRange getB();
 // CHECK:  ::mlir::Value getC();
 // CHECK:  ::mlir::ValueRange getD();
 // CHECK:  ::mlir::DenseIntElementsAttr getOperandSegmentSizes();
 
 // Check op trait for different number of operands
 // ---

 def NS_HCollectiveParamsOp : NS_Op<"op_collective_params", []> {
   let arguments = (ins AnyType:$a);
   let results = (outs AnyType:$b);
 }
 
 // CHECK_LABEL: class NS_HCollectiveParamsOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type b, ::mlir::Value a);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {})
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {})
 
 // Check suppression of "separate arg, separate result" build method for an op
 // with single variadic arg and single variadic result (since it will be
 // ambiguous with the collective params build method).
 def NS_HCollectiveParamsSuppress0Op : NS_Op<"op_collective_suppress0", []> {
   let arguments = (ins Variadic<I32>:$a);
   let results = (outs Variadic<I32>:$b);
 }
 
 // CHECK_LABEL: class NS_HCollectiveParamsSuppress0Op :
 // CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::ValueRange a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Check suppression of "separate arg, collective result" build method for an op
 // with single variadic arg and non variadic result (since it will be
 // ambiguous with the collective params build method).
 def NS_HCollectiveParamsSuppress1Op : NS_Op<"op_collective_suppress1", []> {
   let arguments = (ins Variadic<I32>:$a);
   let results = (outs I32:$b);
 }
 
 // CHECK_LABEL: class NS_HCollectiveParamsSuppress1Op :
 // CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::ValueRange a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Check suppression of "separate arg, collective result" build method for an op
 // with single variadic arg and > 1 variadic result (since it will be
 // ambiguous with the collective params build method). Note that "separate arg,
 // separate result" build method should be generated in this case as its not
 // ambiguous with the collective params build method.
 def NS_HCollectiveParamsSuppress2Op : NS_Op<"op_collective_suppress2", [SameVariadicResultSize]> {
   let arguments = (ins Variadic<I32>:$a);
   let results = (outs Variadic<I32>:$b, Variadic<F32>:$c);
 }
 // CHECK_LABEL: class NS_HCollectiveParamsSuppress2Op :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::TypeRange c, ::mlir::ValueRange a);
 // CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::ValueRange a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Check default value of `attributes` for the `genUseOperandAsResultTypeCollectiveParamBuilder` builder
 def NS_IOp : NS_Op<"op_with_same_operands_and_result_types_trait", [SameOperandsAndResultType]> {
   let arguments = (ins AnyType:$a, AnyType:$b);
   let results = (outs AnyType:$r);
 }
 // CHECK_LABEL: class NS_IOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Check default value of `attributes` for the `genInferredTypeCollectiveParamBuilder` builder
 def NS_JOp : NS_Op<"op_with_InferTypeOpInterface_interface", [DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let arguments = (ins AnyType:$a, AnyType:$b);
   let results = (outs AnyType:$r);
 }
 // CHECK_LABEL: class NS_JOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
-// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes = {});
 
 // Test usage of OpTraitList getting flattened during emission.
 def NS_KOp : NS_Op<"k_op", [IsolatedFromAbove,
     OpTraitList<[DeclareOpInterfaceMethods<InferTypeOpInterface>]>]> {
   let arguments = (ins AnyType:$a, AnyType:$b);
 }
 
 // CHECK: class KOp : public ::mlir::Op<KOp,

mlir/test/mlir-tblgen/op-result.td

 
 def IntegerTypeAttr : TypeAttrBase<"IntegerType", "Integer type attribute">;
 def OpD : NS_Op<"type_attr_as_result_type", [FirstAttrDerivedResultType]> {
   let arguments = (ins I32:$x, IntegerTypeAttr:$attr, F32Attr:$f32);
   let results = (outs AnyTensor:$y);
 }
 
 // CHECK-LABEL: OpD definitions
-// CHECK: void OpD::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes)
+// CHECK: void OpD::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes)
 // CHECK: odsState.addTypes({attr.second.cast<::mlir::TypeAttr>().getValue()});
 
 def OpE : NS_Op<"value_attr_as_result_type", [FirstAttrDerivedResultType]> {
   let arguments = (ins I32:$x, F32Attr:$attr);
   let results = (outs AnyTensor:$y);
 }
 
 // CHECK-LABEL: OpE definitions
-// CHECK: void OpE::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes)
+// CHECK: void OpE::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes)
 // CHECK: odsState.addTypes({attr.second.getType()});
 
 def OpF : NS_Op<"one_variadic_result_op", []> {
   let results = (outs Variadic<I32>:$x);
 }
 
 // CHECK-LABEL: void OpF::build
 // CHECK-SAME:    ::mlir::TypeRange x

 // Test that if the only operand is variadic, we access the first value in the
 // pack to set result type
 // ---
 def OpK : NS_Op<"only_input_is_variadic_with_same_value_type_op", [SameOperandsAndResultType]> {
   let arguments = (ins Variadic<AnyTensor>:$input);
   let results = (outs AnyTensor:$result);
 }
 
-// CHECK-LABEL: OpK::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes)
+// CHECK-LABEL: OpK::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::AttributeRange attributes)
 // CHECK: odsState.addTypes({operands[0].getType()});
 
 // Test with inferred shapes and interleaved with operands/attributes.
 //
 def OpL1 : NS_Op<"op_with_all_types_constraint",
     [AllTypesMatch<["a", "b"]>]> {
   let arguments = (ins I32Attr:$attr1, AnyType:$a);
   let results = (outs Res<AnyType, "output b", []>:$b);

mlir/test/python/python_test_ops.td

 
 def InferResultsOp : TestOp<"infer_results_op", [InferTypeOpInterface]> {
   let arguments = (ins);
   let results = (outs AnyInteger:$single, AnyInteger:$doubled);
 
   let extraClassDeclaration = [{
     static ::mlir::LogicalResult inferReturnTypes(
       ::mlir::MLIRContext *context, ::llvm::Optional<::mlir::Location> location,
-      ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
+      ::mlir::ValueRange operands, ::mlir::AttributeRange attributes,
       ::mlir::RegionRange regions,
       ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
       ::mlir::Builder b(context);
       inferredReturnTypes.push_back(b.getI32Type());
       inferredReturnTypes.push_back(b.getI64Type());
       return ::mlir::success();
     }
   }];

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

/*extraInterfaces=*/[{2}])> {
     );
     let results = (outs Variadic<AnyRankedTensor>:$result_tensors);
     let regions = (region AnyRegion:$region);
 
     let skipDefaultBuilders = 1;
     let builders = [
       OpBuilder<
       (ins "ValueRange":$inputs, "ValueRange":$outputs,
-            CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
+            CArg<"AttributeRange", "{{}">:$attributes),
       [{{
         $_state.addOperands(inputs);
         $_state.addOperands(outputs);
         SmallVector<Type> resultTensorTypes;
         copy_if(outputs.getTypes(),
                 std::back_inserter(resultTensorTypes),
                 [](Type type) {{ return type.isa<RankedTensorType>(); });
         $_state.addTypes(resultTensorTypes);
         $_state.addAttribute(
           "operand_segment_sizes",
           $_builder.getI32VectorAttr({{
             static_cast<int32_t>(inputs.size()),
             static_cast<int32_t>(outputs.size())}));
         $_state.addAttributes(attributes);
         createAndFillStructuredOpRegion<{0}>(
           $_builder,
           $_state,
           TypeRange(inputs),
           TypeRange(outputs));
       }]>,
       OpBuilder<
       (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
             "ValueRange":$outputs,
-            CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
+            CArg<"AttributeRange", "{{}">:$attributes),
       [{{
         $_state.addOperands(inputs);
         $_state.addOperands(outputs);
         $_state.addTypes(resultTensorTypes);
         $_state.addAttributes(attributes);
         $_state.addAttribute(
           "operand_segment_sizes",
           $_builder.getI32VectorAttr({{
             static_cast<int32_t>(inputs.size()),
             static_cast<int32_t>(outputs.size())}));
         createAndFillStructuredOpRegion<{0}>(
           $_builder,
           $_state,
           TypeRange(inputs),
           TypeRange(outputs));
       }]>,
       OpBuilder<
       (ins "TypeRange":$resultTensorTypes, "ValueRange":$operands,
-            CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
+            CArg<"AttributeRange", "{{}">:$attributes),
       [{{
         $_state.addOperands(operands);
         $_state.addAttributes(attributes);
         $_state.addTypes(resultTensorTypes);
         (void)$_state.addRegion();
       }]>
       {5}
     ];

 // Builder method taking attribute parameters. Parameters:
 // {0}: Class name
 // {1}: Comma interleaved attribute parameters
 // {2}: Attribute initialization
 static const char structuredOpBuilderFormat[] = R"FMT(
   , OpBuilder<
   (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
        "ValueRange":$outputs, {1},
-       CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
+       CArg<"AttributeRange", "{{}">:$attributes),
   [{{
     $_state.addOperands(inputs);
     $_state.addOperands(outputs);
     $_state.addTypes(resultTensorTypes);
     $_state.addAttribute(
       "operand_segment_sizes",
       $_builder.getI32VectorAttr({{
         static_cast<int32_t>(inputs.size()),

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 
 // The logic to calculate the actual value range for a declared operand/result
 // of an op with variadic operands/results. Note that this logic is assumes
 // the op has an attribute specifying the size of each operand/result segment
 // (variadic or not).
 //
 // {0}: The name of the attribute specifying the segment sizes.
 const char *adapterSegmentSizeAttrInitCode = R"(
-  assert(odsAttrs && "missing segment size attribute for op");
+  assert(!odsAttrs.empty() && "missing segment size attribute for op");
   auto sizeAttr = odsAttrs.get("{0}").cast<::mlir::DenseIntElementsAttr>();
 )";
 const char *opSegmentSizeAttrInitCode = R"(
-  auto sizeAttr = (*this)->getAttr({0}).cast<::mlir::DenseIntElementsAttr>();
+  auto sizeAttr = (*this)->getOpAttributes().get({0}AttrName(), {0}AttrLeft(),
+                                                 {0}AttrRight())
+                      .cast<::mlir::DenseIntElementsAttr>();
 )";
 const char *attrSizedSegmentValueRangeCalcCode = R"(
   const uint32_t *sizeAttrValueIt = &*sizeAttr.value_begin<uint32_t>();
   if (sizeAttr.isSplat())
     return {*sizeAttrValueIt * index, *sizeAttrValueIt};
 
   unsigned start = 0;
   for (unsigned i = 0; i < index; ++i)

 
 static const char *const opCommentHeader = R"(
 //===----------------------------------------------------------------------===//
 // {0} {1}
 //===----------------------------------------------------------------------===//
 
 )";
 
+/// Attribute subrange get.
+///
+/// {0}: attribute name.
+const char *attrSubrangeGet = "(*this)->getOpAttributes().get({0}AttrName(), "
+                              "{0}AttrLeft(), {0}AttrRight())";
+const char *attrSubrangeGetNamed = "(*this)->getOpAttributes().getNamed({0}"
+                                   "AttrName(), {0}AttrLeft(), {0}AttrRight())";
+const char *attrSubrangeSet = "(*this)->getOpAttributes().set({0}AttrName(), "
+                              "{1}, {0}AttrLeft(), {0}AttrRight())";
+const char *attrSubrangeDefinitelySet =
+    "(*this)->getOpAttributes().definitelySet({0}AttrName(), {1}, "
+    "{0}AttrLeft(), {0}AttrRight())";
+const char *attrSubrangeErase = "(*this)->getOpAttributes().erase({0}AttrName()"
+                                ", {0}AttrLeft(), {0}AttrRight())";
+const char *attrSubrangeGetOrSet = R"(
+  (*this)->getOpAttributes().getOrSet({0}AttrName(), [&] {
+    return {1};
+  }, {0}AttrLeft(), {0}AttrRight())
+)";
+
+const char *adaptorGetAttr = "odsAttrs.get(\"{0}\")";
+
 //===----------------------------------------------------------------------===//
 // Utility structs and functions
 //===----------------------------------------------------------------------===//
 
 // Replaces all occurrences of `match` in `str` with `substitute`.
 static std::string replaceAllSubstrs(std::string str, const std::string &match,
                                      const std::string &substitute) {
   std::string::size_type scanLoc = 0, matchLoc = std::string::npos;
   while ((matchLoc = str.find(match, scanLoc)) != std::string::npos) {
     str = str.replace(matchLoc, match.size(), substitute);
     scanLoc = matchLoc + substitute.size();
   }
   return str;
 }
 
 // Returns whether the record has a value of the given name that can be returned
 // via getValueAsString.
 static inline bool hasStringAttribute(const Record &record,
                                       StringRef fieldName) {
-  auto valueInit = record.getValueInit(fieldName);
+  auto *valueInit = record.getValueInit(fieldName);
   return isa<StringInit>(valueInit);
 }
 
 static std::string getArgumentName(const Operator &op, int index) {
   const auto &operand = op.getOperand(index);
   if (!operand.name.empty())
     return std::string(operand.name);
-  else
-    return std::string(formatv("{0}_{1}", generatedArgName, index));
 }
 
 // Returns true if we can use unwrapped value for the given `attr` in builders.
 static bool canUseUnwrappedRawValue(const tblgen::Attribute &attr) {
   return attr.getReturnType() != attr.getStorageType() &&
          // We need to wrap the raw value into an attribute in the builder impl
          // so we need to make sure that the attribute specifies how to do that.
          !attr.getConstBuilderTemplate().empty();
 }
 
 //===----------------------------------------------------------------------===//
 // Op emitter
 //===----------------------------------------------------------------------===//
 
 namespace {
+struct AttrSubrange {
+  StringRef name;
+  unsigned left, right;
+};
+
 // Helper class to emit a record into the given output stream.
 class OpEmitter {
 public:
   static void
   emitDecl(const Operator &op, raw_ostream &os,
            const StaticVerifierFunctionEmitter &staticVerifierEmitter);
   static void
   emitDef(const Operator &op, raw_ostream &os,
private:
   // The C++ code builder for this op
   OpClass opClass;
 
   // The format context for verification code generation.
   FmtContext verifyCtx;
 
   // The emitter containing all of the locally emitted verification functions.
   const StaticVerifierFunctionEmitter &staticVerifierEmitter;
+
+  // Pre-computed attribute subranges.
+  SmallVector<AttrSubrange> attrSubranges;
 };
 
 } // end anonymous namespace
 
 // Populate the format context `ctx` with substitutions of attributes, operands
 // and results.
 // - attrGet corresponds to the name of the function to call to get value of
 //   attribute (the generated function call returns an Attribute);
 // - operandGet corresponds to the name of the function with which to retrieve
 //   an operand (the generated function call returns an OperandRange);
 // - resultGet corresponds to the name of the function to get an result (the
 //   generated function call returns a ValueRange);
-static void populateSubstitutions(const Operator &op, const char *attrGet,
-                                  const char *operandGet, const char *resultGet,
-                                  FmtContext &ctx) {
+static void populateSubstitutions(const Operator &op, bool opRequired,
+                                  const char *attrGet, const char *operandGet,
+                                  const char *resultGet, FmtContext &ctx) {
   // Populate substitutions for attributes and named operands.
-  for (const auto &namedAttr : op.getAttributes())
+  for (const auto &namedAttr : op.getAttributes()) {
     ctx.addSubst(namedAttr.name,
-                 formatv("{0}(\"{1}\")", attrGet, namedAttr.name));
+                 formatv(attrGet, opRequired ? op.getGetterName(namedAttr.name)
+                                             : namedAttr.name));
+  }
   for (int i = 0, e = op.getNumOperands(); i < e; ++i) {
     auto &value = op.getOperand(i);
     if (value.name.empty())
       continue;
 
     if (value.isVariadic())
       ctx.addSubst(value.name, formatv("{0}({1})", operandGet, i));
     else

 // generated.
 // - emitErrorPrefix is the prefix for the error emitting call which consists
 //   of the entire function call up to start of error message fragment;
 // - emitVerificationRequiringOp specifies whether verification should be
 //   emitted for verification that require the op to exist;
 static void genAttributeVerifier(const Operator &op, const char *attrGet,
                                  const Twine &emitErrorPrefix,
                                  bool emitVerificationRequiringOp,
-                                 FmtContext &ctx, OpMethodBody &body) {
+                                 FmtContext &ctx, OpMethodBody &body,
+                                 bool useOpGetter = false) {
   for (const auto &namedAttr : op.getAttributes()) {
     const auto &attr = namedAttr.attr;
     if (attr.isDerivedAttr())
       continue;
 
     auto attrName = namedAttr.name;
     bool allowMissingAttr = attr.hasDefaultValue() || attr.isOptional();
     auto attrPred = attr.getPredicate();
for (const auto &namedAttr : op.getAttributes()) {
     //
     // Therefore, for optional attributes whose verification requires that an
     // op already exists for verification/emitVerificationRequiringOp is set
     // has nothing that can be verified here.
     if ((allowMissingAttr || emitVerificationRequiringOp) &&
         !hasConditionToEmit)
       continue;
 
-    body << formatv("  {\n  auto {0} = {1}(\"{2}\");\n", varName, attrGet,
-                    attrName);
+    body << formatv("  {\n  auto {0} = ", varName, attrGet, attrName)
+         << formatv(attrGet,
+                    useOpGetter ? op.getGetterName(attrName) : attrName)
+         << ";\n";
 
     if (!emitVerificationRequiringOp && !allowMissingAttr) {
       body << "  if (!" << varName << ") return " << emitErrorPrefix
            << "\"requires attribute '" << attrName << "'\");\n";
     }
 
     if (!hasConditionToEmit) {
       body << "  }\n";
body << tgfmt("    if (!($0)) return $1\"attribute '$2' "
                   /*ctx=*/nullptr, tgfmt(condition, &ctx.withSelf(varName)),
                   emitErrorPrefix, attrName, escapeString(attr.getSummary()));
     if (allowMissingAttr)
       body << "  }\n";
     body << "  }\n";
   }
 }
 
+static SmallVector<AttrSubrange> collectAttrNames(const Operator &op) {
+  // A map of attribute names (including implicit attributes) registered to the
+  // current operation, to whether the attribute is mandatory.
+  llvm::MapVector<StringRef, bool> uniqueAttrNames;
+
+  // Enumerate the attribute names of this op, assigning each a relative
+  // ordering.
+  for (const NamedAttribute &namedAttr : op.getAttributes()) {
+    const Attribute &attr = namedAttr.attr;
+    bool isMandatory =
+        !attr.isDerivedAttr() && !attr.isOptional() && !attr.hasDefaultValue();
+    uniqueAttrNames.insert({namedAttr.name, isMandatory});
+  }
+  // Include key attributes from several traits as implicitly registered.
+  const char *operandSizes = "operand_segment_sizes";
+  if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments"))
+    uniqueAttrNames.insert({operandSizes, true});
+  const char *attrSizes = "result_segment_sizes";
+  if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
+    uniqueAttrNames.insert({attrSizes, true});
+
+  if (uniqueAttrNames.empty())
+    return {};
+
+  // Sort the attribute names so that the search lower and upper bounds can
+  // be determined.
+  std::vector<std::pair<StringRef, bool>> attrNames =
+      uniqueAttrNames.takeVector();
+  std::sort(attrNames.begin(), attrNames.end(),
+            [](auto &lhs, auto &rhs) { return lhs.first < rhs.first; });
+
+  // Determine the number of **mandatory** attributes to the left and right of
+  // each attribute.
+  SmallVector<unsigned> mandatoryLeft(attrNames.size(), 0);
+  unsigned numMandatory = 0;
+  for (auto it : llvm::enumerate(attrNames)) {
+    mandatoryLeft[it.index()] = numMandatory;
+    numMandatory += it.value().second;
+  }
+
+  SmallVector<AttrSubrange> attrSubranges;
+  attrSubranges.reserve(attrNames.size());
+  for (auto it : llvm::zip(attrNames, mandatoryLeft)) {
+    attrSubranges.push_back(AttrSubrange{
+        .name = std::get<0>(it).first,
+        .left = std::get<1>(it),
+        .right = numMandatory - std::get<1>(it) - std::get<0>(it).second});
+  }
+  return attrSubranges;
+}
+
 OpEmitter::OpEmitter(const Operator &op,
                      const StaticVerifierFunctionEmitter &staticVerifierEmitter)
     : def(op.getDef()), op(op),
       opClass(op.getCppClassName(), op.getExtraClassDeclaration()),
-      staticVerifierEmitter(staticVerifierEmitter) {
+      staticVerifierEmitter(staticVerifierEmitter),
+      attrSubranges(collectAttrNames(op)) {
   verifyCtx.withOp("(*this->getOperation())");
   verifyCtx.addSubst("_ctxt", "this->getOperation()->getContext()");
 
   genTraits();
 
   // Generate C++ code for various op methods. The order here determines the
   // methods in the generated file.
   genAttrNameGetters();
static void errorIfPruned(size_t line, OpMethod *m, const Twine &methodName,
   PrintFatalError(op.getLoc(), "Unexpected overlap when generating `" +
                                    methodName + "` for " +
                                    op.getOperationName() + " (from line " +
                                    Twine(line) + ")");
 }
 #define ERROR_IF_PRUNED(M, N, O) errorIfPruned(__LINE__, M, N, O)
 
 void OpEmitter::genAttrNameGetters() {
-  // A map of attribute names (including implicit attributes) registered to the
-  // current operation, to the relative order in which they were registered.
-  llvm::MapVector<StringRef, unsigned> attributeNames;
-
-  // Enumerate the attribute names of this op, assigning each a relative
-  // ordering.
-  auto addAttrName = [&](StringRef name) {
-    unsigned index = attributeNames.size();
-    attributeNames.insert({name, index});
-  };
-  for (const NamedAttribute &namedAttr : op.getAttributes())
-    addAttrName(namedAttr.name);
-  // Include key attributes from several traits as implicitly registered.
-  std::string operandSizes = "operand_segment_sizes";
-  if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments"))
-    addAttrName(operandSizes);
-  std::string attrSizes = "result_segment_sizes";
-  if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
-    addAttrName(attrSizes);
 
   // Emit the getAttributeNames method.
   {
     auto *method = opClass.addMethodAndPrune(
         "::llvm::ArrayRef<::llvm::StringRef>", "getAttributeNames",
         OpMethod::Property(OpMethod::MP_Static | OpMethod::MP_Inline));
     ERROR_IF_PRUNED(method, "getAttributeNames", op);
     auto &body = method->body();
-    if (attributeNames.empty()) {
+    if (attrSubranges.empty()) {
       body << "  return {};";
     } else {
       body << "  static ::llvm::StringRef attrNames[] = {";
-      llvm::interleaveComma(llvm::make_first_range(attributeNames), body,
-                            [&](StringRef attrName) {
-                              body << "::llvm::StringRef(\"" << attrName
-                                   << "\")";
-                            });
+      llvm::interleaveComma(
+          attrSubranges, body, [&](const AttrSubrange attrName) {
+            body << "::llvm::StringRef(\"" << attrName.name << "\")";
       body << "};\n  return ::llvm::makeArrayRef(attrNames);";
     }
   }
-  if (attributeNames.empty())
+  if (attrSubranges.empty())
     return;
 
   // Emit the getAttributeNameForIndex methods.
   {
     auto *method = opClass.addMethodAndPrune(
         "::mlir::Identifier", "getAttributeNameForIndex",
         OpMethod::Property(OpMethod::MP_Private | OpMethod::MP_Inline),
         "unsigned", "index");
     ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op);
     method->body()
         << "  return getAttributeNameForIndex((*this)->getName(), index);";
   }
   {
     auto *method = opClass.addMethodAndPrune(
         "::mlir::Identifier", "getAttributeNameForIndex",
         OpMethod::Property(OpMethod::MP_Private | OpMethod::MP_Inline |
                            OpMethod::MP_Static),
         "::mlir::OperationName name, unsigned index");
     ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op);
-    method->body() << "assert(index < " << attributeNames.size()
+    method->body() << "assert(index < " << attrSubranges.size()
                    << " && \"invalid attribute index\");\n"
                       "  return name.getAbstractOperation()"
                       "->getAttributeNames()[index];";
   }
 
   // Generate the <attr>AttrName methods, that expose the attribute names to
   // users.
   const char *attrNameMethodBody = "  return getAttributeNameForIndex({0});";
-  for (const std::pair<StringRef, unsigned> &attrIt : attributeNames) {
-    for (StringRef name : op.getGetterNames(attrIt.first)) {
+  for (auto attrIt : llvm::enumerate(attrSubranges)) {
+    for (StringRef name : op.getGetterNames(attrIt.value().name)) {
       std::string methodName = (name + "AttrName").str();
 
       // Generate the non-static variant.
       {
         auto *method =
             opClass.addMethodAndPrune("::mlir::Identifier", methodName,
                                       OpMethod::Property(OpMethod::MP_Inline));
         ERROR_IF_PRUNED(method, methodName, op);
         method->body()
-            << llvm::formatv(attrNameMethodBody, attrIt.second).str();
+            << llvm::formatv(attrNameMethodBody, attrIt.index()).str();
       }
 
       // Generate the static variant.
       {
         auto *method = opClass.addMethodAndPrune(
             "::mlir::Identifier", methodName,
             OpMethod::Property(OpMethod::MP_Inline | OpMethod::MP_Static),
             "::mlir::OperationName", "name");
         ERROR_IF_PRUNED(method, methodName, op);
         method->body() << llvm::formatv(attrNameMethodBody,
-                                        "name, " + Twine(attrIt.second))
+                                        "name, " + Twine(attrIt.index()))
                               .str();
       }
     }
   }
+
+  // <attr>AttrLeft, <attr>AttrRight
+  for (auto &subrange : attrSubranges) {
+    for (StringRef name : op.getGetterNames(subrange.name)) {
+      {
+        std::string methodName = (name + "AttrLeft").str();
+        auto *method = opClass.addMethodAndPrune(
+            "unsigned", methodName,
+            OpMethod::Property(OpMethod::MP_Inline | OpMethod::MP_Static));
+        ERROR_IF_PRUNED(method, methodName, op);
+        method->body() << "  return " << subrange.left << ";";
+      }
+      {
+        std::string methodName = (name + "AttrRight").str();
+        auto *method = opClass.addMethodAndPrune(
+            "unsigned", methodName,
+            OpMethod::Property(OpMethod::MP_Inline | OpMethod::MP_Static));
+        ERROR_IF_PRUNED(method, methodName, op);
+        method->body() << "  return " << subrange.right << ";";
+      }
+    }
+  }
 }
 
 void OpEmitter::genAttrGetters() {
   FmtContext fctx;
   fctx.withBuilder("::mlir::Builder((*this)->getContext())");
 
   // Emit the derived attribute body.
   auto emitDerivedAttr = [&](StringRef name, Attribute attr) {
     if (auto *method = opClass.addMethodAndPrune(attr.getReturnType(), name))
       method->body() << "  " << attr.getDerivedCodeBody() << "\n";
   };
 
   // Emit with return type specified.
   auto emitAttrWithReturnType = [&](StringRef name, Attribute attr) {
     auto *method = opClass.addMethodAndPrune(attr.getReturnType(), name);
     ERROR_IF_PRUNED(method, name, op);
     auto &body = method->body();
-    body << "  auto attr = " << name << "Attr();\n";
+    body << "  auto attr = ";
     if (attr.hasDefaultValue()) {
-      // Returns the default value if not set.
-      // TODO: this is inefficient, we are recreating the attribute for every
-      // call. This should be set instead.
-      std::string defaultValue = std::string(
+      body << formatv(
+          attrSubrangeGetOrSet, name,
           tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
-      body << "    if (!attr)\n      return "
-           << tgfmt(attr.getConvertFromStorageCall(),
-                    &fctx.withSelf(defaultValue))
-           << ";\n";
+    } else {
+      body << name << "Attr()";
     }
-    body << "  return "
+    body << ";\n  return "
          << tgfmt(attr.getConvertFromStorageCall(), &fctx.withSelf("attr"))
          << ";\n";
   };
 
   // Generate named accessor with Attribute return type. This is a wrapper class
   // that allows referring to the attributes via accessors instead of having to
   // use the string interface for better compile time verification.
   auto emitAttrWithStorageType = [&](StringRef name, Attribute attr) {
     auto *method =
         opClass.addMethodAndPrune(attr.getStorageType(), (name + "Attr").str());
     if (!method)
       return;
     auto &body = method->body();
-    body << "  return (*this)->getAttr(" << name << "AttrName()).template ";
+    body << "  return " << formatv(attrSubrangeGet, name) << ".template ";
     if (attr.isOptional() || attr.hasDefaultValue())
       body << "dyn_cast_or_null<";
     else
       body << "cast<";
     body << attr.getStorageType() << ">();";
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {

 void OpEmitter::genAttrSetters() {
   // Generate raw named setter type. This is a wrapper class that allows setting
   // to the attributes via setters instead of having to use the string interface
   // for better compile time verification.
   auto emitAttrWithStorageType = [&](StringRef setterName, StringRef getterName,
                                      Attribute attr) {
     auto *method = opClass.addMethodAndPrune(
         "void", (setterName + "Attr").str(), attr.getStorageType(), "attr");
-    if (method)
-      method->body() << "  (*this)->setAttr(" << getterName
-                     << "AttrName(), attr);";
+    if (method) {
+      method->body() << "  "
+                     << formatv(attr.isOptional() || attr.hasDefaultValue()
+                                    ? attrSubrangeSet
+                                    : attrSubrangeDefinitelySet,
+                                getterName, "attr")
+                     << ";\n";
+    }
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
-    if (!namedAttr.attr.isDerivedAttr())
-      for (auto names : llvm::zip(op.getSetterNames(namedAttr.name),
-                                  op.getGetterNames(namedAttr.name)))
-        emitAttrWithStorageType(std::get<0>(names), std::get<1>(names),
-                                namedAttr.attr);
+    if (namedAttr.attr.isDerivedAttr())
+      continue;
+                                op.getGetterNames(namedAttr.name))) {
     }
   }
+}
 
 void OpEmitter::genOptionalAttrRemovers() {
   // Generate methods for removing optional attributes, instead of having to
   // use the string interface. Enables better compile time verification.
   auto emitRemoveAttr = [&](StringRef name) {
     auto upperInitial = name.take_front().upper();
     auto suffix = name.drop_front();
     auto *method = opClass.addMethodAndPrune(
         "::mlir::Attribute", ("remove" + upperInitial + suffix + "Attr").str());
     if (!method)
       return;
-    method->body() << "  return (*this)->removeAttr(" << op.getGetterName(name)
-                   << "AttrName());";
+    method->body() << "  return "
+                   << formatv(attrSubrangeErase, op.getGetterName(name))
+                   << ";\n";
   };
 
-  for (const NamedAttribute &namedAttr : op.getAttributes())
+  for (const NamedAttribute &namedAttr : op.getAttributes()) {
     if (namedAttr.attr.isOptional())
       emitRemoveAttr(namedAttr.name);
   }
+}
 
 // Generates the code to compute the start and end index of an operand or result
 // range.
 template <typename RangeT>
 static void
 generateValueRangeStartAndEnd(Class &opClass, StringRef methodName,
                               int numVariadic, int numNonVariadic,
                               StringRef rangeSizeCall, bool hasAttrSegmentSize,
static void generateNamedOperandGetters(const Operator &op, Class &opClass,
   }
 }
 
 void OpEmitter::genNamedOperandGetters() {
   // Build the code snippet used for initializing the operand_segment_size)s
   // array.
   std::string attrSizeInitCode;
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
-    std::string attr = op.getGetterName("operand_segment_sizes") + "AttrName()";
-    attrSizeInitCode = formatv(opSegmentSizeAttrInitCode, attr).str();
+    attrSizeInitCode = formatv(opSegmentSizeAttrInitCode,
+                               op.getGetterName("operand_segment_sizes"))
+                           .str();
   }
 
   generateNamedOperandGetters(
       op, opClass,
       /*isAdaptor=*/false,
       /*sizeAttrInit=*/attrSizeInitCode,
       /*rangeType=*/"::mlir::Operation::operand_range",
       /*rangeBeginCall=*/"getOperation()->operand_begin()",
for (StringRef name : op.getGetterNames(operand.name)) {
                                          : "::mlir::MutableOperandRange",
           (name + "Mutable").str());
       ERROR_IF_PRUNED(m, name, op);
       auto &body = m->body();
       body << "  auto range = getODSOperandIndexAndLength(" << i << ");\n"
            << "  auto mutableRange = "
               "::mlir::MutableOperandRange(getOperation(), "
               "range.first, range.second";
-      if (attrSizedOperands)
-        body << ", ::mlir::MutableOperandRange::OperandSegment(" << i
-             << "u, *getOperation()->getAttrDictionary().getNamed("
-             << op.getGetterName("operand_segment_sizes") << "AttrName()))";
+      if (attrSizedOperands) {
+        body << ", ::mlir::MutableOperandRange::OperandSegment(" << i << "u, *"
+             << formatv(attrSubrangeGetNamed,
+                        op.getGetterName("operand_segment_sizes"))
+             << ")";
+      }
       body << ");\n";
 
       // If this operand is a nested variadic, we split the range into a
       // MutableOperandRangeRange that provides a range over all of the
       // sub-ranges.
       if (operand.isVariadicOfVariadic()) {
         //
         body << "  return "
-                "mutableRange.split(*(*this)->getAttrDictionary().getNamed("
+                "mutableRange.split(*(*this)->getNamedAttr("
              << op.getGetterName(
                     operand.constraint.getVariadicOfVariadicSegmentSizeAttr())
              << "AttrName()));\n";
       } else {
         // Otherwise, we use the full range directly.
         body << "  return mutableRange;\n";
       }
     }
if (attrSizedResults && sameVariadicSize) {
     PrintFatalError(op.getLoc(),
                     "op cannot have both 'AttrSizedResultSegments' and "
                     "'SameVariadicResultSize' traits");
   }
 
   // Build the initializer string for the result segment size attribute.
   std::string attrSizeInitCode;
   if (attrSizedResults) {
-    std::string attr = op.getGetterName("result_segment_sizes") + "AttrName()";
-    attrSizeInitCode = formatv(opSegmentSizeAttrInitCode, attr).str();
+    attrSizeInitCode = formatv(opSegmentSizeAttrInitCode,
+                               op.getGetterName("result_segment_sizes"))
+                           .str();
   }
 
   generateValueRangeStartAndEnd(
       opClass, "getODSResultIndexAndLength", numVariadicResults,
       numNormalResults, "getOperation()->getNumResults()", attrSizedResults,
       attrSizeInitCode, op.getResults());
 
   auto *m = opClass.addMethodAndPrune("::mlir::Operation::result_range",
if (inferType) {
       // Generate builder that infers type too.
       // TODO: Subsume this with general checking if type can be
       // inferred automatically.
       // TODO: Expand to handle regions.
       body << formatv(R"(
         ::llvm::SmallVector<::mlir::Type, 2> inferredReturnTypes;
         if (::mlir::succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
                       {1}.location, {1}.operands,
-                      {1}.attributes.getDictionary({1}.getContext()),
-                      /*regions=*/{{}, inferredReturnTypes)))
+                      {1}.attributes, /*regions=*/{{}, inferredReturnTypes)))
           {1}.addTypes(inferredReturnTypes);
         else
           ::llvm::report_fatal_error("Failed to infer result type(s).");)",
                       opClass.getClassName(), builderOpState);
       return;
     }
 
     switch (paramKind) {
void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
 
   // Signature
   llvm::SmallVector<OpMethodParameter, 4> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
   // Provide default value for `attributes` when its the last parameter
   StringRef attributesDefaultValue = op.getNumVariadicRegions() ? "" : "{}";
-  paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
-                         "attributes", attributesDefaultValue);
+  paramList.emplace_back("::mlir::AttributeRange", "attributes",
+                         attributesDefaultValue);
   if (op.getNumVariadicRegions())
     paramList.emplace_back("unsigned", "numRegions");
 
   auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
                                       std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;

 }
 
 void OpEmitter::genInferredTypeCollectiveParamBuilder() {
   // TODO: Expand to support regions.
   SmallVector<OpMethodParameter, 4> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
-  paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
-                         "attributes", "{}");
+  paramList.emplace_back("::mlir::AttributeRange", "attributes", "{}");
   auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
                                       std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
   auto &body = m->body();
 
   int numResults = op.getNumResults();
if (int numRegions = op.getNumRegions()) {
     body << "    (void)" << builderOpState << ".addRegion();\n";
   }
 
   // Result types
   body << formatv(R"(
     ::mlir::SmallVector<::mlir::Type, 2> inferredReturnTypes;
     if (::mlir::succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
                   {1}.location, operands,
-                  {1}.attributes.getDictionary({1}.getContext()),
-                  /*regions=*/{{}, inferredReturnTypes))) {{)",
+                  {1}.attributes, /*regions=*/{{}, inferredReturnTypes))) {{)",
                   opClass.getClassName(), builderOpState);
   if (numVariadicResults == 0 || numNonVariadicResults != 0)
     body << "  assert(inferredReturnTypes.size()"
          << (numVariadicResults != 0 ? " >= " : " == ") << numNonVariadicResults
          << "u && \"mismatched number of return types\");\n";
   body << "      " << builderOpState << ".addTypes(inferredReturnTypes);";
 
   body << formatv(R"(
void OpEmitter::genUseOperandAsResultTypeSeparateParamBuilder() {
   body << "});\n\n";
 }
 
 void OpEmitter::genUseAttrAsResultTypeBuilder() {
   SmallVector<OpMethodParameter, 4> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
-  paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
-                         "attributes", "{}");
+  paramList.emplace_back("::mlir::AttributeRange", "attributes", "{}");
   auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
                                       std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
 
   auto &body = m->body();
 
void OpEmitter::genCollectiveParamBuilder() {
 
   SmallVector<OpMethodParameter, 4> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::TypeRange", "resultTypes");
   paramList.emplace_back("::mlir::ValueRange", "operands");
   // Provide default value for `attributes` when its the last parameter
   StringRef attributesDefaultValue = op.getNumVariadicRegions() ? "" : "{}";
-  paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
-                         "attributes", attributesDefaultValue);
+  paramList.emplace_back("::mlir::AttributeRange", "attributes",
+                         attributesDefaultValue);
   if (op.getNumVariadicRegions())
     paramList.emplace_back("unsigned", "numRegions");
 
   auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
                                       std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
if (type.isArg()) {
       auto argIndex = type.getArg();
       assert(!op.getArg(argIndex).is<NamedAttribute *>());
       auto arg = op.getArgToOperandOrAttribute(argIndex);
       if (arg.kind() == Operator::OperandOrAttribute::Kind::Operand)
         return body << "operands[" << arg.operandOrAttributeIndex()
                     << "].getType()";
       return body << "attributes[" << arg.operandOrAttributeIndex()
                   << "].getType()";
-    } else {
-      return body << tgfmt(*type.getType().getBuilderCall(), &fctx);
     }
+    return body << tgfmt(*type.getType().getBuilderCall(), &fctx);
   };
 
   for (int i = 0, e = op.getNumResults(); i != e; ++i) {
     body << "  inferredReturnTypes[" << i << "] = ";
     auto types = op.getSameTypeAsResult(i);
     emitType(types[0]) << ";\n";
     if (types.size() == 1)
       continue;
void OpEmitter::genParser() {
   auto parser = def.getValueAsString("parser").ltrim().rtrim(" \t\v\f\r");
   method->body() << "  " << tgfmt(parser, &fctx);
 }
 
 void OpEmitter::genPrinter() {
   if (hasStringAttribute(def, "assemblyFormat"))
     return;
 
-  auto valueInit = def.getValueInit("printer");
+  auto *valueInit = def.getValueInit("printer");
   StringInit *stringInit = dyn_cast<StringInit>(valueInit);
   if (!stringInit)
     return;
 
   auto *method =
       opClass.addMethodAndPrune("void", "print", "::mlir::OpAsmPrinter &", "p");
   ERROR_IF_PRUNED(method, "print", op);
   FmtContext fctx;
   fctx.addSubst("cppClass", opClass.getClassName());
   auto printer = stringInit->getValue().ltrim().rtrim(" \t\v\f\r");
   method->body() << "  " << tgfmt(printer, &fctx);
 }
 
+static void genOpOrAdaptorVerifier(OpMethodBody &body, const Operator &op,
+                                   bool opRequired, FmtContext &verifyCtx) {
+  const char *const checkAttrSizedValueSegmentsCode = R"(
+  {
+    auto sizeAttr = {3}.cast<::mlir::DenseIntElementsAttr>();
+    auto numElements = sizeAttr.getType().cast<::mlir::ShapedType>()
+                               .getNumElements();
+    if (numElements != {1})
+      return {4}"'{0}' attribute for specifying {2} segments must have {1} "
+             "elements, but got ") << numElements;
+  }
+  )";
+
+  std::string emitError =
+      opRequired ? "emitOpError("
+                 : ("emitError(loc, \"'" + op.getOperationName() + "' op \"");
+
+  // Use subrange getter on the Operation if inside of one.
+  const char *const attrGetter = opRequired ? attrSubrangeGet : adaptorGetAttr;
+  const auto checkSegmentAttr = [&](StringRef attrName, unsigned count,
+                                    StringRef errNoun) {
+    body << formatv(
+        checkAttrSizedValueSegmentsCode, attrName, count, errNoun,
+        formatv(attrGetter, opRequired ? op.getGetterName(attrName) : attrName),
+        emitError);
+  };
+
+  // Verify a few traits first so that we can use
+  // getODSOperands()/getODSResults() in the rest of the verifier.
+  for (auto &trait : op.getTraits()) {
+    if (auto *t = dyn_cast<tblgen::NativeTrait>(&trait)) {
+      if (t->getFullyQualifiedTraitName() ==
+          "::mlir::OpTrait::AttrSizedOperandSegments") {
+        checkSegmentAttr("operand_segment_sizes", op.getNumOperands(),
+                         "operand");
+      } else if (t->getFullyQualifiedTraitName() ==
+                 "::mlir::OpTrait::AttrSizedResultSegments") {
+        checkSegmentAttr("result_segment_sizes", op.getNumResults(), "result");
+      }
+    }
+  }
+
+  populateSubstitutions(op, opRequired, attrGetter, "getODSOperands",
+                        "<no results should be generated>", verifyCtx);
+  genAttributeVerifier(op, attrGetter, emitError,
+                       /*emitVerificationRequiringOp=*/false, verifyCtx, body,
+                       /*useOpGetter=*/opRequired);
+}
+
 void OpEmitter::genVerifier() {
   auto *method = opClass.addMethodAndPrune("::mlir::LogicalResult", "verify");
   ERROR_IF_PRUNED(method, "verify", op);
   auto &body = method->body();
-  body << "  if (::mlir::failed(" << op.getAdaptorName()
-       << "(*this).verify((*this)->getLoc()))) "
-       << "return ::mlir::failure();\n";
+  // body << "  if (::mlir::failed(" << op.getAdaptorName()
+  //      << "(*this).verify((*this)->getLoc()))) "
+  //      << "return ::mlir::failure();\n";
+  genOpOrAdaptorVerifier(body, op, /*opRequired=*/true, verifyCtx);
 
   auto *valueInit = def.getValueInit("verifier");
   StringInit *stringInit = dyn_cast<StringInit>(valueInit);
   bool hasCustomVerify = stringInit && !stringInit->getValue().empty();
-  populateSubstitutions(op, "(*this)->getAttr", "this->getODSOperands",
-                        "this->getODSResults", verifyCtx);
-
-  genAttributeVerifier(op, "(*this)->getAttr", "emitOpError(",
-                       /*emitVerificationRequiringOp=*/true, verifyCtx, body);
+  populateSubstitutions(op, /*opRequired=*/true, attrSubrangeGet,
+                        "this->getODSOperands", "this->getODSResults",
+                        verifyCtx);
+
+  genAttributeVerifier(op, attrSubrangeGet, "emitOpError(",
+                       /*emitVerificationRequiringOp=*/true, verifyCtx, body,
+                       /*useOpGetter=*/true);
   genOperandResultVerifier(body, op.getOperands(), "operand");
   genOperandResultVerifier(body, op.getResults(), "result");
 
   for (auto &trait : op.getTraits()) {
     if (auto *t = dyn_cast<tblgen::PredTrait>(&trait)) {
       body << tgfmt("  if (!($0))\n    "
                     "return emitOpError(\"failed to verify that $1\");\n",
                     &verifyCtx, tgfmt(t->getPredTemplate(), &verifyCtx),
default:
       opClass.addTrait("::mlir::OpTrait::NOperands<" + Twine(numOperands) +
                        ">::Impl");
       break;
     }
   }
 
   // Add the native and interface traits.
   for (const auto &trait : op.getTraits()) {
-    if (auto opTrait = dyn_cast<tblgen::NativeTrait>(&trait))
+    if (auto *opTrait = dyn_cast<tblgen::NativeTrait>(&trait))
       opClass.addTrait(opTrait->getFullyQualifiedTraitName());
-    else if (auto opTrait = dyn_cast<tblgen::InterfaceTrait>(&trait))
+    else if (auto *opTrait = dyn_cast<tblgen::InterfaceTrait>(&trait))
       opClass.addTrait(opTrait->getFullyQualifiedTraitName());
   }
 }
 
 void OpEmitter::genOpNameGetter() {
   auto *method = opClass.addMethodAndPrune(
       "::llvm::StringLiteral", "getOperationName",
       OpMethod::Property(OpMethod::MP_Static | OpMethod::MP_Constexpr));
private:
   // which verifies all the op-independent attribute constraints.
   void addVerification();
 
   const Operator &op;
   Class adaptor;
 };
 } // end namespace
 
+/// Code template to get an attribute in an OpAdaptor.
+///
+/// {0}: Attribute storage type.
+/// {1}: Attribute name.
+/// {2}: `cast` for required attributes, `dyn_cast_or_null` for optional or
+///      default-valued attributes.
+static const char *const opAdaptorGetAttr = R"(
+  {0} attr = odsAttrs.get("{1}").{2}<{0}>();
+)";
+
+/// Code template to materialize an attribute's default value in an OpAdaptor,
+/// if a value for the attribute was not found.
+///
+/// TODO: This is inefficient because default values are materialized each call.
+///       However, OpAdaptor is an immutable view on an Operation-like.
+///
+/// {0}: Code snippet to construct the attribute's default value;
+static const char *const opAdaptorConstructDefaultAttr = R"(
+  if (!attr)
+    attr = {0};
+)";
+
 OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(const Operator &op)
     : op(op), adaptor(op.getAdaptorName()) {
+  adaptor.newField("::mlir::MLIRContext *", "odsContext");
   adaptor.newField("::mlir::ValueRange", "odsOperands");
-  adaptor.newField("::mlir::DictionaryAttr", "odsAttrs");
+  adaptor.newField("::mlir::AttributeRange", "odsAttrs");
   adaptor.newField("::mlir::RegionRange", "odsRegions");
   const auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   {
     SmallVector<OpMethodParameter, 2> paramList;
+    paramList.emplace_back("::mlir::MLIRContext *", "mlirContext");
     paramList.emplace_back("::mlir::ValueRange", "values");
-    paramList.emplace_back("::mlir::DictionaryAttr", "attrs",
-                           attrSizedOperands ? "" : "nullptr");
+    paramList.emplace_back("::mlir::AttributeRange", "attrs",
+                           attrSizedOperands ? "" : "{}");
     paramList.emplace_back("::mlir::RegionRange", "regions", "{}");
     auto *constructor = adaptor.addConstructorAndPrune(std::move(paramList));
 
+    constructor->addMemberInitializer("odsContext", "mlirContext");
     constructor->addMemberInitializer("odsOperands", "values");
     constructor->addMemberInitializer("odsAttrs", "attrs");
     constructor->addMemberInitializer("odsRegions", "regions");
   }
 
   {
     auto *constructor = adaptor.addConstructorAndPrune(
         llvm::formatv("{0}&", op.getCppClassName()).str(), "op");
+    constructor->addMemberInitializer("odsContext", "op->getContext()");
     constructor->addMemberInitializer("odsOperands", "op->getOperands()");
-    constructor->addMemberInitializer("odsAttrs", "op->getAttrDictionary()");
+    constructor->addMemberInitializer("odsAttrs", "op->getAttrs()");
     constructor->addMemberInitializer("odsRegions", "op->getRegions()");
   }
 
   {
     auto *m = adaptor.addMethodAndPrune("::mlir::ValueRange", "getOperands");
     ERROR_IF_PRUNED(m, "getOperands", op);
     m->body() << "  return odsOperands;";
   }
   std::string attr = "operand_segment_sizes";
   std::string sizeAttrInit = formatv(adapterSegmentSizeAttrInitCode, attr);
   generateNamedOperandGetters(op, adaptor,
                               /*isAdaptor=*/true, sizeAttrInit,
                               /*rangeType=*/"::mlir::ValueRange",
                               /*rangeBeginCall=*/"odsOperands.begin()",
                               /*rangeSizeCall=*/"odsOperands.size()",
                               /*getOperandCallPattern=*/"odsOperands[{0}]");
 
   FmtContext fctx;
-  fctx.withBuilder("::mlir::Builder(odsAttrs.getContext())");
+  fctx.withBuilder("::mlir::Builder(odsContext)");
 
   auto emitAttr = [&](StringRef name, Attribute attr) {
     auto *method = adaptor.addMethodAndPrune(attr.getStorageType(), name);
     ERROR_IF_PRUNED(method, "Adaptor::" + name, op);
     auto &body = method->body();
-    body << "  assert(odsAttrs && \"no attributes when constructing adapter\");"
-         << "\n  " << attr.getStorageType() << " attr = "
-         << "odsAttrs.get(\"" << name << "\").";
-    if (attr.hasDefaultValue() || attr.isOptional())
-      body << "dyn_cast_or_null<";
-    else
-      body << "cast<";
-    body << attr.getStorageType() << ">();\n";
+    body << formatv(opAdaptorGetAttr, attr.getStorageType(), name,
+                    attr.hasDefaultValue() || attr.isOptional()
+                        ? "dyn_cast_or_null"
+                        : "cast");
 
     if (attr.hasDefaultValue()) {
-      // Use the default value if attribute is not set.
-      // TODO: this is inefficient, we are recreating the attribute for every
-      // call. This should be set instead.
-      std::string defaultValue = std::string(
+      body << formatv(
+          opAdaptorConstructDefaultAttr,
           tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
-      body << "  if (!attr)\n    attr = " << defaultValue << ";\n";
     }
     body << "  return attr;\n";
   };
 
   {
     auto *m =
-        adaptor.addMethodAndPrune("::mlir::DictionaryAttr", "getAttributes");
+        adaptor.addMethodAndPrune("::mlir::AttributeRange", "getAttributes");
     ERROR_IF_PRUNED(m, "Adaptor::getAttributes", op);
     m->body() << "  return odsAttrs;";
   }
   for (auto &namedAttr : op.getAttributes()) {
     const auto &name = namedAttr.name;
     const auto &attr = namedAttr.attr;
     if (!attr.isDerivedAttr()) {
-      for (auto emitName : op.getGetterNames(name))
+      for (auto &emitName : op.getGetterNames(name))
         emitAttr(emitName, attr);
     }
   }
 
   unsigned numRegions = op.getNumRegions();
   if (numRegions > 0) {
     auto *m = adaptor.addMethodAndPrune("::mlir::RegionRange", "getRegions");
     ERROR_IF_PRUNED(m, "Adaptor::getRegions", op);
OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(const Operator &op)
   // Add verification function.
   addVerification();
 }
 
 void OpOperandAdaptorEmitter::addVerification() {
   auto *method = adaptor.addMethodAndPrune("::mlir::LogicalResult", "verify",
                                            "::mlir::Location", "loc");
   ERROR_IF_PRUNED(method, "verify", op);
-  auto &body = method->body();
-
-  const char *checkAttrSizedValueSegmentsCode = R"(
-  {
-    auto sizeAttr = odsAttrs.get("{0}").cast<::mlir::DenseIntElementsAttr>();
-    auto numElements = sizeAttr.getType().cast<::mlir::ShapedType>().getNumElements();
-    if (numElements != {1})
-      return emitError(loc, "'{0}' attribute for specifying {2} segments "
-                       "must have {1} elements, but got ") << numElements;
-  }
-  )";
-
-  // Verify a few traits first so that we can use
-  // getODSOperands()/getODSResults() in the rest of the verifier.
-  for (auto &trait : op.getTraits()) {
-    if (auto *t = dyn_cast<tblgen::NativeTrait>(&trait)) {
-      if (t->getFullyQualifiedTraitName() ==
-          "::mlir::OpTrait::AttrSizedOperandSegments") {
-        body << formatv(checkAttrSizedValueSegmentsCode,
-                        "operand_segment_sizes", op.getNumOperands(),
-                        "operand");
-      } else if (t->getFullyQualifiedTraitName() ==
-                 "::mlir::OpTrait::AttrSizedResultSegments") {
-        body << formatv(checkAttrSizedValueSegmentsCode, "result_segment_sizes",
-                        op.getNumResults(), "result");
-      }
-    }
-  }
-
   FmtContext verifyCtx;
-  populateSubstitutions(op, "odsAttrs.get", "getODSOperands",
-                        "<no results should be generated>", verifyCtx);
-  genAttributeVerifier(op, "odsAttrs.get",
-                       Twine("emitError(loc, \"'") + op.getOperationName() +
-                           "' op \"",
-                       /*emitVerificationRequiringOp*/ false, verifyCtx, body);
-
-  body << "  return ::mlir::success();";
+  genOpOrAdaptorVerifier(method->body(), op,
+                         /*opRequired=*/false, verifyCtx);
+  method->body() << "  return ::mlir::success();\n";
 }
 
 void OpOperandAdaptorEmitter::emitDecl(const Operator &op, raw_ostream &os) {
   OpOperandAdaptorEmitter(op).adaptor.writeDeclTo(os);
 }
 
 void OpOperandAdaptorEmitter::emitDef(const Operator &op, raw_ostream &os) {
   OpOperandAdaptorEmitter(op).adaptor.writeDefTo(os);

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 
 /// The code snippet used to generate a parser call to infer return types.
 ///
 /// {0}: The operation class name
 const char *const inferReturnTypesParserCode = R"(
   ::llvm::SmallVector<::mlir::Type> inferredReturnTypes;
   if (::mlir::failed({0}::inferReturnTypes(parser.getContext(),
       result.location, result.operands,
-      result.attributes.getDictionary(parser.getContext()),
-      result.regions, inferredReturnTypes)))
+      result.attributes, result.regions, inferredReturnTypes)))
     return ::mlir::failure();
   result.addTypes(inferredReturnTypes);
 )";
 
 /// The code snippet used to generate a parser call for a region list.
 ///
 /// {0}: The name for the region list.
 const char *regionListParserCode = R"(

 /// The code snippet used to generate a printer call for a region of an
 // operation that has the SingleBlockImplicitTerminator trait.
 ///
 /// {0}: The name of the region.
 const char *regionSingleBlockImplicitTerminatorPrinterCode = R"(
   {
     bool printTerminator = true;
     if (auto *term = {0}.empty() ? nullptr : {0}.begin()->getTerminator()) {{
-      printTerminator = !term->getAttrDictionary().empty() ||
+      printTerminator = !term->getAttrs().empty() ||
                         term->getNumOperands() != 0 ||
                         term->getNumResults() != 0;
     }
     p.printRegion({0}, /*printEntryBlockArgs=*/true,
                   /*printBlockTerminators=*/printTerminator);
   }
 )";
 

 /// Generate the printer for a custom directive parameter.
 static void genCustomDirectiveParameterPrinter(Element *element,
                                                const Operator &op,
                                                OpMethodBody &body) {
   if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     body << op.getGetterName(attr->getVar()->name) << "Attr()";
 
   } else if (isa<AttrDictDirective>(element)) {
-    body << "getOperation()->getAttrDictionary()";
+    body << "getOperation()->getAttrs()";
 
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     body << op.getGetterName(operand->getVar()->name) << "()";
 
   } else if (auto *region = dyn_cast<RegionVariable>(element)) {
     body << op.getGetterName(region->getVar()->name) << "()";
 
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {