Cleanup uses of getAttrDictionary() in MLIR to use getDiscardableAttrDictionary() when possible

[mehdi_amini]

Summary

This also speeds up some benchmarks in compiling simple fortan file by 2x!
Fixes #62687

[rriddle]

mlir/lib/Dialect/Func/Transforms/DuplicateFunctionElimination.cpp

57–58

Why commented out? Can we remove dead code?

[mehdi_amini]

mlir/lib/Dialect/Func/Transforms/DuplicateFunctionElimination.cpp

57–58

Actually this is a lingering bug, thanks for noticing I had forgotten.

We can't implement a "compare these properties equals BUT for one field" generically. Luckily this isn't a generic method!

I'll remove the change in this file and sending it in a separate review.

[mehdi_amini]

Remove changes to DuplicateFunctionElimination.cpp

[PeteSteinfeld]

Thanks for the fast action on this, @mehdi_amini! This solves my performance problem, and flang builds correctly and passes all of the lit tests.

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

explicit ConvertOpToLLVMPattern(LLVMTypeConverter &typeConverter,
                              &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 {
     if constexpr (SourceOp::hasProperties())
       rewrite(cast<SourceOp>(op),
-              OpAdaptor(operands, op->getAttrDictionary(),
+              OpAdaptor(operands, op->getDiscardableAttrDictionary(),
                         cast<SourceOp>(op).getProperties()),
               rewriter);
-    rewrite(cast<SourceOp>(op), OpAdaptor(operands, op->getAttrDictionary()),
-            rewriter);
+    rewrite(cast<SourceOp>(op),
+            OpAdaptor(operands, op->getDiscardableAttrDictionary()), rewriter);
   }
   LogicalResult match(Operation *op) const final {
     return match(cast<SourceOp>(op));
   }
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     if constexpr (SourceOp::hasProperties())
       return matchAndRewrite(cast<SourceOp>(op),
-                             OpAdaptor(operands, op->getAttrDictionary(),
+                             OpAdaptor(operands,
+                                       op->getDiscardableAttrDictionary(),
                                        cast<SourceOp>(op).getProperties()),
                              rewriter);
-    return matchAndRewrite(cast<SourceOp>(op),
-                           OpAdaptor(operands, op->getAttrDictionary()),
-                           rewriter);
+    return matchAndRewrite(
+        cast<SourceOp>(op),
+        OpAdaptor(operands, op->getDiscardableAttrDictionary()), rewriter);
   }
 
   /// 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 {
     llvm_unreachable("must override match or matchAndRewrite");
   }
   virtual void rewrite(SourceOp op, OpAdaptor adaptor,

mlir/include/mlir/IR/OpDefinition.h

private:
   template <typename ConcreteOpT>
   static LogicalResult
   foldSingleResultHook(Operation *op, ArrayRef<Attribute> operands,
                        SmallVectorImpl<OpFoldResult> &results) {
     OpFoldResult result;
     if constexpr (has_fold_adaptor_single_result_v<ConcreteOpT>) {
       if constexpr (hasProperties()) {
         result = cast<ConcreteOpT>(op).fold(typename ConcreteOpT::FoldAdaptor(
-            operands, op->getAttrDictionary(),
+            operands, op->getDiscardableAttrDictionary(),
             cast<ConcreteOpT>(op).getProperties(), op->getRegions()));
       } else {
         result = cast<ConcreteOpT>(op).fold(typename ConcreteOpT::FoldAdaptor(
-            operands, op->getAttrDictionary(), {}, op->getRegions()));
+            operands, op->getDiscardableAttrDictionary(), {},
+            op->getRegions()));
       }
     } else {
       result = cast<ConcreteOpT>(op).fold(operands);
     }
 
     // If the fold failed or was in-place, try to fold the traits of the
     // operation.
     if (!result || result.template dyn_cast<Value>() == op->getResult(0)) {
private:
   template <typename ConcreteOpT>
   static LogicalResult foldHook(Operation *op, ArrayRef<Attribute> operands,
                                 SmallVectorImpl<OpFoldResult> &results) {
     auto result = LogicalResult::failure();
     if constexpr (has_fold_adaptor_v<ConcreteOpT>) {
       if constexpr (hasProperties()) {
         result = cast<ConcreteOpT>(op).fold(
             typename ConcreteOpT::FoldAdaptor(
-                operands, op->getAttrDictionary(),
+                operands, op->getDiscardableAttrDictionary(),
                 cast<ConcreteOpT>(op).getProperties(), op->getRegions()),
             results);
       } else {
         result = cast<ConcreteOpT>(op).fold(
-            typename ConcreteOpT::FoldAdaptor(operands, op->getAttrDictionary(),
-                                              {}, op->getRegions()),
+            typename ConcreteOpT::FoldAdaptor(
+                operands, op->getDiscardableAttrDictionary(), {},
+                op->getRegions()),
             results);
       }
     } else {
       result = cast<ConcreteOpT>(op).fold(operands, results);
     }
 
     // If the fold failed or was in-place, try to fold the traits of the
     // operation.

mlir/include/mlir/Transforms/DialectConversion.h

public:
 
   /// Wrappers around the ConversionPattern methods that pass the derived op
   /// type.
   LogicalResult match(Operation *op) const final {
     return match(cast<SourceOp>(op));
   }
   void rewrite(Operation *op, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const final {
-    rewrite(cast<SourceOp>(op), OpAdaptor(operands, op->getAttrDictionary()),
+    auto sourceOp = cast<SourceOp>(op);
+    rewrite(sourceOp,
+            OpAdaptor(operands, op->getDiscardableAttrDictionary(),
+                      sourceOp.getProperties()),
             rewriter);
   }
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     auto sourceOp = cast<SourceOp>(op);
     if constexpr (SourceOp::hasProperties())
       return matchAndRewrite(sourceOp,
-                             OpAdaptor(operands, op->getAttrDictionary(),
+                             OpAdaptor(operands,
+                                       op->getDiscardableAttrDictionary(),
                                        sourceOp.getProperties()),
                              rewriter);
     return matchAndRewrite(
-        sourceOp, OpAdaptor(operands, op->getAttrDictionary()), rewriter);
+        sourceOp, OpAdaptor(operands, op->getDiscardableAttrDictionary()),
+        rewriter);
   }
 
   /// 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 {
     llvm_unreachable("must override match or matchAndRewrite");
   }
   virtual void rewrite(SourceOp op, OpAdaptor adaptor,

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

struct ReallocOpLoweringBase : public AllocationOpLLVMLowering {
   /// aligned pointer.
   virtual std::tuple<Value, Value>
   allocateBuffer(ConversionPatternRewriter &rewriter, Location loc,
                  Value sizeBytes, memref::ReallocOp op) const = 0;
 
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
-    return matchAndRewrite(cast<memref::ReallocOp>(op),
-                           OpAdaptor(operands, op->getAttrDictionary()),
+    auto reallocOp = cast<memref::ReallocOp>(op);
+    return matchAndRewrite(reallocOp,
+                           OpAdaptor(operands,
+                                     op->getDiscardableAttrDictionary(),
+                                     reallocOp.getProperties()),
                            rewriter);
   }
 
   // A `realloc` is converted as follows:
   //   If new_size > old_size
   //     1. allocates a new buffer
   //     2. copies the content of the old buffer to the new buffer
   //     3. release the old buffer

mlir/lib/Dialect/Func/Transforms/DuplicateFunctionElimination.cpp

func.getBody().walk([&](Operation *op) {
                     /*hashResults=*/OperationEquivalence::ignoreHashValue,
                     OperationEquivalence::IgnoreLocations));
     });
 
     return hash;
   }
 
   static bool isEqual(const func::FuncOp cLhs, const func::FuncOp cRhs) {
-    if (cLhs == cRhs) {
+    if (cLhs == cRhs)
       return true;
-    }
     if (cLhs == getTombstoneKey() || cLhs == getEmptyKey() ||
-        cRhs == getTombstoneKey() || cRhs == getEmptyKey()) {
+        cRhs == getTombstoneKey() || cRhs == getEmptyKey())
       return false;
-    }
+    // if (cLhs->hashProperties() != cRhs->hashProperties())
+    //   return false;
 
-    // Check attributes equivalence, ignoring the symbol name.
-    if (cLhs->getAttrDictionary().size() != cRhs->getAttrDictionary().size()) {
+    // Check discardable attributes equivalence, ignoring the symbol name.
+    if (cLhs->getDiscardableAttrDictionary().size() !=
+        cRhs->getDiscardableAttrDictionary().size())
       return false;
-    }
     func::FuncOp lhs = const_cast<func::FuncOp &>(cLhs);
-    StringAttr symNameAttrName = lhs.getSymNameAttrName();
-    for (NamedAttribute namedAttr : cLhs->getAttrs()) {
+    for (NamedAttribute namedAttr : cLhs->getDiscardableAttrDictionary()) {
       StringAttr attrName = namedAttr.getName();
-      if (attrName == symNameAttrName) {
-        continue;
-      }
-      if (namedAttr.getValue() != cRhs->getAttr(attrName)) {
+      if (namedAttr.getValue() != cRhs->getDiscardableAttr(attrName)) {
         return false;
       }
     }
 
     // Compare inner workings.
     func::FuncOp rhs = const_cast<func::FuncOp &>(cRhs);
     return OperationEquivalence::isRegionEquivalentTo(
         &lhs.getBody(), &rhs.getBody(), OperationEquivalence::IgnoreLocations);

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

LogicalResult rewriteAsyncOp(gpu::AsyncOpInterface asyncOp) {
     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->getPropertiesStorage(),
-                                    op->getSuccessors(), op->getNumRegions());
+    auto *newOp = Operation::create(
+        op->getLoc(), op->getName(), resultTypes, op->getOperands(),
+        op->getDiscardableAttrDictionary(), op->getPropertiesStorage(),
 
     // Clone regions into new op.
     IRMapping 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.
     auto results = newOp->getResults();

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->getDiscardableAttrDictionary() ==
+               rhs->getDiscardableAttrDictionary() &&
+           lhs->hashProperties() == rhs->hashProperties();
   }
 
   // Returns a source value for the given block.
   Value getSrcValue(Block *block) const {
     auto storeOp = cast<spirv::StoreOp>(block->front());
     return storeOp.getValue();
   }
 

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

 }
 
 LogicalResult tosa::ArgMaxOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes,
     OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
-  IntegerAttr axis = attributes.get("axis").cast<IntegerAttr>();
+  auto *prop = properties.as<Properties *>();
+  IntegerAttr axis = prop->axis;
   int32_t axisVal = axis.getValue().getSExtValue();
 
   if (!inputShape.hasRank()) {
     inferredReturnShapes.push_back(ShapedTypeComponents());
     return success();
   }
 
   SmallVector<int64_t> outShape;

 }
 
 LogicalResult tosa::ConcatOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes,
     OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   // Infer all dimension sizes by reducing based on inputs.
-  int32_t axis =
-      attributes.get("axis").cast<IntegerAttr>().getValue().getSExtValue();
+  auto *prop = properties.as<Properties *>();
+  int32_t axis = prop->axis.getValue().getSExtValue();
   llvm::SmallVector<int64_t> outputShape;
   bool hasRankedInput = false;
   for (auto operand : operands) {
     ShapeAdaptor operandShape = operands.getShape(operand);
     if (!operandShape.hasRank())
       continue;
 
     // Copy the Operand's rank.
#define REDUCE_SHAPE_INFER(OP)                                                 \
   LogicalResult OP::inferReturnTypeComponents(                                 \
       MLIRContext *context, ::std::optional<Location> location,                \
       ValueShapeRange operands, DictionaryAttr attributes,                     \
       OpaqueProperties properties, RegionRange regions,                        \
       SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {           \
     Type inputType =                                                           \
         operands.getType()[0].cast<TensorType>().getElementType();             \
     return ReduceInferReturnTypes(operands.getShape(0), inputType,             \
-                                  attributes.get("axis").cast<IntegerAttr>(),  \
+                                  properties.as<Properties *>()->axis,         \
                                   inferredReturnShapes);                       \
   }                                                                            \
   COMPATIBLE_RETURN_TYPES(OP)
 
 REDUCE_SHAPE_INFER(tosa::ReduceAllOp)
 REDUCE_SHAPE_INFER(tosa::ReduceAnyOp)
 REDUCE_SHAPE_INFER(tosa::ReduceMaxOp)
 REDUCE_SHAPE_INFER(tosa::ReduceMinOp)

 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,
+    ArrayRef<int64_t> kernel, ArrayRef<int64_t> stride, ArrayRef<int64_t> pad,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   llvm::SmallVector<int64_t> outputShape;
   outputShape.resize(4, ShapedType::kDynamic);
 
   // We only know the rank if the input type is unranked.
   if (!inputShape) {
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
 
   // Batch and number of channels are identical for pooling layer.
   outputShape[0] = inputShape.getDimSize(0);
   outputShape[3] = inputShape.getDimSize(3);
 
   int64_t height = inputShape.getDimSize(1);
   int64_t width = inputShape.getDimSize(2);
 
-  ArrayRef<int64_t> kernel = attributes.get("kernel").cast<DenseI64ArrayAttr>();
-  ArrayRef<int64_t> stride = attributes.get("stride").cast<DenseI64ArrayAttr>();
-  ArrayRef<int64_t> pad = attributes.get("pad").cast<DenseI64ArrayAttr>();
-
   if (!ShapedType::isDynamic(height)) {
     int64_t padded = height + pad[0] + pad[1] - kernel[0];
     outputShape[1] = padded / stride[0] + 1;
   }
 
   if (!ShapedType::isDynamic(width)) {
     int64_t padded = width + pad[2] + pad[3] - kernel[1];
     outputShape[2] = padded / stride[1] + 1;

 
 LogicalResult Conv3DOp::verify() { return verifyConvOp(*this); }
 
 LogicalResult AvgPool2dOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes,
     OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
+  Properties &prop = *properties.as<Properties *>();
+  return poolingInferReturnTypes(operands, attributes, prop.kernel, prop.stride,
+                                 prop.pad, inferredReturnShapes);
 }
 
 LogicalResult MaxPool2dOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes,
     OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
+  Properties &prop = *properties.as<Properties *>();
+  return poolingInferReturnTypes(operands, attributes, prop.kernel, prop.stride,
+                                 prop.pad, inferredReturnShapes);
 }
 
 LogicalResult DepthwiseConv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes,
     OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(4, ShapedType::kDynamic);

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

TosaOp createOpAndInfer(PatternRewriter &rewriter, Location loc, Type resultTy,
 
   InferShapedTypeOpInterface shapeInterface =
       dyn_cast<InferShapedTypeOpInterface>(op.getOperation());
   if (!shapeInterface)
     return op;
 
   SmallVector<ShapedTypeComponents> returnedShapes;
   if (shapeInterface
-          .inferReturnTypeComponents(op.getContext(), op.getLoc(),
-                                     op->getOperands(), op->getAttrDictionary(),
-                                     op->getPropertiesStorage(),
-                                     op->getRegions(), returnedShapes)
+          .inferReturnTypeComponents(
+              op.getContext(), op.getLoc(), op->getOperands(),
+              op->getDiscardableAttrDictionary(), op->getPropertiesStorage(),
           .failed())
     return op;
 
   // We need to use the element type of the existing result type to generate
   // the new result shaped type. This is because rescale can include a cast to
   // different bit-width types and does not have a TypeAttr to define the
   // target type.
   auto result = op->getResult(0);

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

for (Operation &op : block) {
           dyn_cast<InferShapedTypeOpInterface>(op);
       if (!shapeInterface)
         continue;
 
       SmallVector<ShapedTypeComponents> returnedShapes;
 
       ValueShapeRange range(op.getOperands(), operandShape);
       if (shapeInterface
-              .inferReturnTypeComponents(
-                  op.getContext(), op.getLoc(), range, op.getAttrDictionary(),
-                  op.getPropertiesStorage(), op.getRegions(), returnedShapes)
+              .inferReturnTypeComponents(op.getContext(), op.getLoc(), range,
+                                         op.getDiscardableAttrDictionary(),
+                                         op.getPropertiesStorage(),
+                                         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/OperationSupport.cpp

 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(),
+      llvm::hash_combine(op->getName(), op->getDiscardableAttrDictionary(),
                          op->getResultTypes(), op->hashProperties());
 
   //   - Operands
   ValueRange operands = op->getOperands();
   SmallVector<Value> operandStorage;
   if (op->hasTrait<mlir::OpTrait::IsCommutative>()) {
     operandStorage.append(operands.begin(), operands.end());
     llvm::sort(operandStorage, [](Value a, Value b) -> bool {
/*static*/ bool OperationEquivalence::isEquivalentTo(
     Operation *lhs, Operation *rhs,
     function_ref<LogicalResult(Value, Value)> checkEquivalent,
     function_ref<void(Value, Value)> markEquivalent, Flags flags) {
   if (lhs == rhs)
     return true;
 
   // 1. Compare the operation properties.
   if (lhs->getName() != rhs->getName() ||
-      lhs->getAttrDictionary() != rhs->getAttrDictionary() ||
+      lhs->getDiscardableAttrDictionary() !=
+          rhs->getDiscardableAttrDictionary() ||
       lhs->getNumRegions() != rhs->getNumRegions() ||
       lhs->getNumSuccessors() != rhs->getNumSuccessors() ||
       lhs->getNumOperands() != rhs->getNumOperands() ||
-      lhs->getNumResults() != rhs->getNumResults())
+      lhs->getNumResults() != rhs->getNumResults() ||
+      lhs->hashProperties() != rhs->hashProperties())
     return false;
   if (!(flags & IgnoreLocations) && lhs->getLoc() != rhs->getLoc())
     return false;
 
   // 2. Compare operands.
   ValueRange lhsOperands = lhs->getOperands(), rhsOperands = rhs->getOperands();
   SmallVector<Value> lhsOperandStorage, rhsOperandStorage;
   if (lhs->hasTrait<mlir::OpTrait::IsCommutative>()) {

 OperationFingerPrint::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());
+    addDataToHash(hasher, op->getDiscardableAttrDictionary());
+    //   - Properties
+    addDataToHash(hasher, op->hashProperties());
     //   - 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/IR/Verifier.cpp

 /// ops are returned in the opsWithIsolatedRegions vector.
 LogicalResult OperationVerifier::verifyOperation(Operation &op) {
   // Check that operands are non-nil and structurally ok.
   for (auto operand : op.getOperands())
     if (!operand)
       return op.emitError("null operand found");
 
   /// Verify that all of the attributes are okay.
-  for (auto attr : op.getAttrs()) {
+  for (auto attr : op.getDiscardableAttrDictionary()) {
     // Check for any optional dialect specific attributes.
     if (auto *dialect = attr.getNameDialect())
       if (failed(dialect->verifyOperationAttribute(&op, attr)))
         return failure();
   }
 
   // If we can get operation info for this, check the custom hook.
   OperationName opName = op.getName();

mlir/lib/Interfaces/InferTypeOpInterface.cpp

LogicalResult mlir::detail::inferReturnTensorTypes(
   return success();
 }
 
 LogicalResult mlir::detail::verifyInferredResultTypes(Operation *op) {
   SmallVector<Type, 4> inferredReturnTypes(op->getResultTypes());
   auto retTypeFn = cast<InferTypeOpInterface>(op);
   auto result = retTypeFn.refineReturnTypes(
       op->getContext(), op->getLoc(), op->getOperands(),
-      op->getAttrDictionary(), op->getPropertiesStorage(), op->getRegions(),
-      inferredReturnTypes);
+      op->getDiscardableAttrDictionary(), op->getPropertiesStorage(),
+      op->getRegions(), inferredReturnTypes);
   if (failed(result))
     op->emitOpError() << "failed to infer returned types";
 
   return result;
 }

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

static void invokeCreateWithInferredReturnType(Operation *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, std::nullopt, values, op->getAttrDictionary(),
+              context, std::nullopt, values, op->getDiscardableAttrDictionary(),
               op->getPropertiesStorage(), op->getRegions(),
               inferredReturnTypes))) {
         OperationState state(location, OpTy::getOperationName());
         // TODO: Expand to regions.
         OpTy::build(b, state, values, op->getAttrs());
         (void)b.create(state);
       }
     }

mlir/test/lib/IR/TestOperationEquals.cpp

void runOnOperation() override {
     if (opCount != 2) {
       module.emitError() << "expected 2 top-level ops in the module, got "
                          << opCount;
       return signalPassFailure();
     }
 
     Operation *first = &module.getBody()->front();
     llvm::outs() << first->getName().getStringRef() << " with attr "
-                 << first->getAttrDictionary();
+                 << first->getDiscardableAttrDictionary();
     OperationEquivalence::Flags flags{};
     if (!first->hasAttr("strict_loc_check"))
       flags |= OperationEquivalence::IgnoreLocations;
     if (OperationEquivalence::isEquivalentTo(first, &module.getBody()->back(),
                                              flags))
       llvm::outs() << " compares equals.\n";
     else
       llvm::outs() << " compares NOT equals!\n";