[mlir] Add method to populate default attributes

[jpienaar]

Summary

Add hook to populate default attributes and generate method for ODS ops.
Previously default attributes were only usable by way of the ODS generated
accessors, but this was undesirable as

1. The ODS getters could construct Attribute each get request;
2. For non-C++ uses this would require either duplicating some of the default attribute generating or generating additional bindings to generate methods;
3. Accessing op.getAttr("foo") and op.getFoo() would return different results;

The hook can be used to address these.

This merely adds this facility but does not employ by default on any path.

[rriddle]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1595–1601

Can we avoid generating the method at all if we don't need to populate it?

1615

If this method also took the OperationName, you could use the cached StringAttrs for the attribute names instead of using the raw string.

[jpienaar]

Pass in OperationName and use cached StringAttrs.

[jpienaar]

(I think I can avoid passing in the context, will revise)

[jpienaar]

Switched to OperationName but kept MLIRContext as input. Context could be
avoided but for unregistered ops it becomes indirect/unituitive (and
restricting to registered is unnecessary).

[rriddle]

In what cases would these methods get called by an unregistered operation? i.e. when does the MLIRContext come into play?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1611

Should we just have the input opName be the registered version? Also OperationName is pointer-like, so you don't really need to use const &.

1614

nit: Drop the braces here.

[jpienaar]

In D128962#3632093, @rriddle wrote:

In what cases would these methods get called by an unregistered operation? i.e. when does the MLIRContext come into play?

I was thinking where you'd have ops relying on dialect fallback hook (so dialect is registered, dialect allows for unregistered ops and op isn't). Except where dialect of op is not registered we'd be able to query the context on the dialect of the OperationName. The dialect example af start was only case with unregistered op which I thought was useful, for unregistered dialects I can't really imagine (but that's also as I almost never have those except for pure testing). So we can remove it if we don't care about unregistered dialects, folks would just need to recall that they can query the context on the dialect.

[jpienaar]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1611

Good point about pointer, so only case to discuss is the unregistered op of registered dialect case that would push this one way or another. (Will update once at desk)

[jfurtek]

I think that this has the potential to improve Python bindings for operations with default-valued attributes. (I believe that at the moment, in most cases the generated Python op creation code requires a value to be provided for an attribute that has a default value.)

I am wondering, though, if this is the best approach. This seems to create a "two phase" construction for operations: the operation is created, and then later (hopefullly!) the default attributes are set. So, for example, a custom builder for an operation with a default-valued attribute doesn't really have all of the "information" - that won't happen until the default attributes of the operation are populated.

An alternative approach might be to have a function that populates a named attribute list given a registered operation name, and this list could be passed to the builder that takes an arrayref of named attributes. (This might even be more efficient in situations where the attribute list could be reused to create multiple operations.)

Maybe I'm drawing too much on how C++ works, or maybe I'm stuck in the Attribute/Type mode of thinking (where creation via getChecked() can fail). Just throwing this out as an idea...

[rriddle]

In D128962#3632691, @jpienaar wrote:

In D128962#3632093, @rriddle wrote:

In what cases would these methods get called by an unregistered operation? i.e. when does the MLIRContext come into play?

I was thinking where you'd have ops relying on dialect fallback hook (so dialect is registered, dialect allows for unregistered ops and op isn't). Except where dialect of op is not registered we'd be able to query the context on the dialect of the OperationName. The dialect example af start was only case with unregistered op which I thought was useful, for unregistered dialects I can't really imagine (but that's also as I almost never have those except for pure testing). So we can remove it if we don't care about unregistered dialects, folks would just need to recall that they can query the context on the dialect.

These methods aren't called by unregistered operations though (given the use within on RegisteredOperationName)? So do we need the context? or are you thinking of some extension here?

[jpienaar]

In D128962#3633055, @jfurtek wrote:

I think that this has the potential to improve Python bindings for operations with default-valued attributes. (I believe that at the moment, in most cases the generated Python op creation code requires a value to be provided for an attribute that has a default value.)

Indeed, that is one of the goals (as the special casing there feels bad).

I am wondering, though, if this is the best approach. This seems to create a "two phase" construction for operations: the operation is created, and then later (hopefullly!) the default attributes are set. So, for example, a custom builder for an operation with a default-valued attribute doesn't really have all of the "information" - that won't happen until the default attributes of the operation are populated.

An alternative approach might be to have a function that populates a named attribute list given a registered operation name, and this list could be passed to the builder that takes an arrayref of named attributes. (This might even be more efficient in situations where the attribute list could be reused to create multiple operations.)

Maybe I'm drawing too much on how C++ works, or maybe I'm stuck in the Attribute/Type mode of thinking (where creation via getChecked() can fail). Just throwing this out as an idea...

That is what is exposed on the RegisteredOperation (populating a NamedAttributeList), so that we can integrate this with the builder and run before the op is created. But you are correct that that isn't exposed C API side that way. So you'd have a more efficient way of doing this C++ side but not C side. I was planning on making this default internally to Python C++ code, so that Python side this would always be the behavior and even for all ODS generated methods. I had considered default for all create calls ... but undecided there as I would want to leave option for where caller knows that all attributes have been populated and so no checking is needed (I think that cost isn't significant enough to special case but would leave that discussion for then :))

[jpienaar]

In D128962#3633799, @rriddle wrote:

In D128962#3632691, @jpienaar wrote:

In D128962#3632093, @rriddle wrote:

In what cases would these methods get called by an unregistered operation? i.e. when does the MLIRContext come into play?

I was thinking where you'd have ops relying on dialect fallback hook (so dialect is registered, dialect allows for unregistered ops and op isn't). Except where dialect of op is not registered we'd be able to query the context on the dialect of the OperationName. The dialect example af start was only case with unregistered op which I thought was useful, for unregistered dialects I can't really imagine (but that's also as I almost never have those except for pure testing). So we can remove it if we don't care about unregistered dialects, folks would just need to recall that they can query the context on the dialect.

These methods aren't called by unregistered operations though (given the use within on RegisteredOperationName)? So do we need the context? or are you thinking of some extension here?

You are correct, I somehow forgot that I'm putting this effectively as restriction already and that if I wanted a different case an extension would be needed. Sold, I'll revert back to using RegisterOperationName and removing context.

mlir/include/mlir/IR/ExtensibleDialect.h

private:
   ExtensibleDialect *dialect;
 
   OperationName::VerifyInvariantsFn verifyFn;
   OperationName::VerifyRegionInvariantsFn verifyRegionFn;
   OperationName::ParseAssemblyFn parseFn;
   OperationName::PrintAssemblyFn printFn;
   OperationName::FoldHookFn foldHookFn;
   OperationName::GetCanonicalizationPatternsFn getCanonicalizationPatternsFn;
+  OperationName::PopulateDefaultAttrsFn getPopulateDefaultAttrsFn;
 
   friend ExtensibleDialect;
 };
 
 //===----------------------------------------------------------------------===//
 // Extensible dialect
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/IR/OpDefinition.h

public:
 
   // These are default implementations of customization hooks.
 public:
   /// This hook returns any canonicalization pattern rewrites that the operation
   /// supports, for use by the canonicalization pass.
   static void getCanonicalizationPatterns(RewritePatternSet &results,
                                           MLIRContext *context) {}
 
+  /// This hook populates any unset default attrs.
+  static void populateDefaultAttrs(const RegisteredOperationName &,
+                                   NamedAttrList &) {}
+
 protected:
   /// If the concrete type didn't implement a custom verifier hook, just fall
   /// back to this one which accepts everything.
   LogicalResult verify() { return success(); }
   LogicalResult verifyRegions() { return success(); }
 
   /// Parse the custom form of an operation. Unless overridden, this method will
   /// first try to get an operation parser from the op's dialect. Otherwise the
private:
   getPrintAssemblyFnImpl() {
     return &printAssembly;
   }
   static void printAssembly(Operation *op, OpAsmPrinter &p,
                             StringRef defaultDialect) {
     OpState::printOpName(op, p, defaultDialect);
     return cast<ConcreteType>(op).print(p);
   }
+  /// Implementation of `PopulateDefaultAttrsFn` OperationName hook.
+  static OperationName::PopulateDefaultAttrsFn getPopulateDefaultAttrsFn() {
+    return ConcreteType::populateDefaultAttrs;
+  }
   /// Implementation of `VerifyInvariantsFn` OperationName hook.
   static LogicalResult verifyInvariants(Operation *op) {
     static_assert(hasNoDataMembers(),
                   "Op class shouldn't define new data members");
     return failure(
         failed(op_definition_impl::verifyTraits<Traits<ConcreteType>...>(op)) ||
         failed(cast<ConcreteType>(op).verify()));
   }

mlir/include/mlir/IR/Operation.h

void setDialectAttrs(DialectAttrT &&dialectAttrs) {
     NamedAttrList attrs;
     attrs.append(std::begin(dialectAttrs), std::end(dialectAttrs));
     for (auto attr : getAttrs())
       if (!attr.getName().strref().contains('.'))
         attrs.push_back(attr);
     setAttrs(attrs.getDictionary(getContext()));
   }
 
+  /// Sets default attributes on unset attributes.
+  void populateDefaultAttrs() {
+    if (auto registered = getRegisteredInfo()) {
+      NamedAttrList attrs(getAttrDictionary());
+      registered->populateDefaultAttrs(attrs);
+      setAttrs(attrs.getDictionary(getContext()));
+    }
+  }
+
   //===--------------------------------------------------------------------===//
   // Blocks
   //===--------------------------------------------------------------------===//
 
   /// Returns the number of regions held by this operation.
   unsigned getNumRegions() { return numRegions; }
 
   /// Returns the regions held by this operation.

mlir/include/mlir/IR/OperationSupport.h

 class BitVector;
 } // namespace llvm
 
 namespace mlir {
 class Dialect;
 class DictionaryAttr;
 class ElementsAttr;
 class MutableOperandRangeRange;
+class NamedAttrList;
 class Operation;
 struct OperationState;
 class OpAsmParser;
 class OpAsmParserResult;
 class OpAsmPrinter;
 class OperandRange;
 class OperandRangeRange;
 class OpFoldResult;

 public:
   using GetCanonicalizationPatternsFn =
       llvm::unique_function<void(RewritePatternSet &, MLIRContext *) const>;
   using FoldHookFn = llvm::unique_function<LogicalResult(
       Operation *, ArrayRef<Attribute>, SmallVectorImpl<OpFoldResult> &) const>;
   using HasTraitFn = llvm::unique_function<bool(TypeID) const>;
   using ParseAssemblyFn =
       llvm::unique_function<ParseResult(OpAsmParser &, OperationState &) const>;
+  // Note: RegisteredOperationName is passed as reference here as the derived
+  // class is defined below.
+  using PopulateDefaultAttrsFn = llvm::unique_function<void(
+      const RegisteredOperationName &, NamedAttrList &) const>;
   using PrintAssemblyFn =
       llvm::unique_function<void(Operation *, OpAsmPrinter &, StringRef) const>;
   using VerifyInvariantsFn =
       llvm::unique_function<LogicalResult(Operation *) const>;
   using VerifyRegionInvariantsFn =
       llvm::unique_function<LogicalResult(Operation *) const>;
 
 protected:
struct Impl {
     /// A map of interfaces that were registered to this operation.
     detail::InterfaceMap interfaceMap;
 
     /// Internal callback hooks provided by the op implementation.
     FoldHookFn foldHookFn;
     GetCanonicalizationPatternsFn getCanonicalizationPatternsFn;
     HasTraitFn hasTraitFn;
     ParseAssemblyFn parseAssemblyFn;
+    PopulateDefaultAttrsFn populateDefaultAttrsFn;
     PrintAssemblyFn printAssemblyFn;
     VerifyInvariantsFn verifyInvariantsFn;
     VerifyRegionInvariantsFn verifyRegionInvariantsFn;
 
     /// A list of attribute names registered to this operation in StringAttr
     /// form. This allows for operation classes to use StringAttr for attribute
     /// lookup/creation/etc., as opposed to raw strings.
     ArrayRef<StringAttr> attributeNames;
public:
   /// This constructor is used by Dialect objects when they register the list of
   /// operations they contain.
   template <typename T>
   static void insert(Dialect &dialect) {
     insert(T::getOperationName(), dialect, TypeID::get<T>(),
            T::getParseAssemblyFn(), T::getPrintAssemblyFn(),
            T::getVerifyInvariantsFn(), T::getVerifyRegionInvariantsFn(),
            T::getFoldHookFn(), T::getGetCanonicalizationPatternsFn(),
-           T::getInterfaceMap(), T::getHasTraitFn(), T::getAttributeNames());
+           T::getInterfaceMap(), T::getHasTraitFn(), T::getAttributeNames(),
+           T::getPopulateDefaultAttrsFn());
   }
   /// The use of this method is in general discouraged in favor of
   /// 'insert<CustomOp>(dialect)'.
   static void
   insert(StringRef name, Dialect &dialect, TypeID typeID,
          ParseAssemblyFn &&parseAssembly, PrintAssemblyFn &&printAssembly,
          VerifyInvariantsFn &&verifyInvariants,
          VerifyRegionInvariantsFn &&verifyRegionInvariants,
          FoldHookFn &&foldHook,
          GetCanonicalizationPatternsFn &&getCanonicalizationPatterns,
          detail::InterfaceMap &&interfaceMap, HasTraitFn &&hasTrait,
-         ArrayRef<StringRef> attrNames);
+         ArrayRef<StringRef> attrNames,
+         PopulateDefaultAttrsFn &&populateDefaultAttrs);
 
   /// Return the dialect this operation is registered to.
   Dialect &getDialect() const { return *impl->dialect; }
 
   /// Return the unique identifier of the derived Op class.
   TypeID getTypeID() const { return impl->typeID; }
 
   /// Use the specified object to parse this ops custom assembly format.
public:
   /// ODS generator to directly access the cached name for a known attribute,
   /// greatly simplifying the cost and complexity of attribute usage produced by
   /// the generator.
   ///
   ArrayRef<StringAttr> getAttributeNames() const {
     return impl->attributeNames;
   }
 
+  /// This hook implements the method to populate defaults attributes that are
+  /// unset.
+  void populateDefaultAttrs(NamedAttrList &attrs) const;
+
   /// Represent the operation name as an opaque pointer. (Used to support
   /// PointerLikeTypeTraits).
   static RegisteredOperationName getFromOpaquePointer(const void *pointer) {
     return RegisteredOperationName(
         const_cast<Impl *>(reinterpret_cast<const Impl *>(pointer)));
   }
 
 private:

mlir/lib/IR/ExtensibleDialect.cpp

assert(op->dialect == this &&
          "trying to register a dynamic op in the wrong dialect");
   auto hasTraitFn = [](TypeID traitId) { return false; };
 
   RegisteredOperationName::insert(
       op->name, *op->dialect, op->typeID, std::move(op->parseFn),
       std::move(op->printFn), std::move(op->verifyFn),
       std::move(op->verifyRegionFn), std::move(op->foldHookFn),
       std::move(op->getCanonicalizationPatternsFn),
-      detail::InterfaceMap::get<>(), std::move(hasTraitFn), {});
+      detail::InterfaceMap::get<>(), std::move(hasTraitFn), {},
+      std::move(op->getPopulateDefaultAttrsFn));
 }
 
 bool ExtensibleDialect::classof(const Dialect *dialect) {
   return const_cast<Dialect *>(dialect)
       ->getRegisteredInterface<IsExtensibleDialect>();
 }
 
 OptionalParseResult ExtensibleDialect::parseOptionalDynamicType(

mlir/lib/IR/MLIRContext.cpp

 }
 
 ParseResult
 RegisteredOperationName::parseAssembly(OpAsmParser &parser,
                                        OperationState &result) const {
   return impl->parseAssemblyFn(parser, result);
 }
 
+void RegisteredOperationName::populateDefaultAttrs(NamedAttrList &attrs) const {
+  impl->populateDefaultAttrsFn(*this, attrs);
+}
+
 void RegisteredOperationName::insert(
     StringRef name, Dialect &dialect, TypeID typeID,
     ParseAssemblyFn &&parseAssembly, PrintAssemblyFn &&printAssembly,
     VerifyInvariantsFn &&verifyInvariants,
     VerifyRegionInvariantsFn &&verifyRegionInvariants, FoldHookFn &&foldHook,
     GetCanonicalizationPatternsFn &&getCanonicalizationPatterns,
     detail::InterfaceMap &&interfaceMap, HasTraitFn &&hasTrait,
-    ArrayRef<StringRef> attrNames) {
+    ArrayRef<StringRef> attrNames,
+    PopulateDefaultAttrsFn &&populateDefaultAttrs) {
   MLIRContext *ctx = dialect.getContext();
   auto &ctxImpl = ctx->getImpl();
   assert(ctxImpl.multiThreadedExecutionContext == 0 &&
          "registering a new operation kind while in a multi-threaded execution "
          "context");
 
   // Register the attribute names of this operation.
   MutableArrayRef<StringAttr> cachedAttrNames;
void RegisteredOperationName::insert(
   impl.foldHookFn = std::move(foldHook);
   impl.getCanonicalizationPatternsFn = std::move(getCanonicalizationPatterns);
   impl.hasTraitFn = std::move(hasTrait);
   impl.parseAssemblyFn = std::move(parseAssembly);
   impl.printAssemblyFn = std::move(printAssembly);
   impl.verifyInvariantsFn = std::move(verifyInvariants);
   impl.verifyRegionInvariantsFn = std::move(verifyRegionInvariants);
   impl.attributeNames = cachedAttrNames;
+  impl.populateDefaultAttrsFn = std::move(populateDefaultAttrs);
 }
 
 //===----------------------------------------------------------------------===//
 // AbstractType
 //===----------------------------------------------------------------------===//
 
 const AbstractType &AbstractType::lookup(TypeID typeID, MLIRContext *context) {
   const AbstractType *type = lookupMutable(typeID, context);

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

private:
   void genNamedResultGetters();
 
   // Generates getters for named regions.
   void genNamedRegionGetters();
 
   // Generates getters for named successors.
   void genNamedSuccessorGetters();
 
+  // Generates the method to populate default attributes.
+  void genPopulateDefaultAttributes();
+
   // Generates builder methods for the operation.
   void genBuilder();
 
   // Generates the build() method that takes each operand/attribute
   // as a stand-alone parameter.
   void genSeparateArgParamBuilder();
 
   // Generates the build() method that takes each operand/attribute as a
OpEmitter::OpEmitter(const Operator &op,
   genNamedOperandSetters();
   genNamedResultGetters();
   genNamedRegionGetters();
   genNamedSuccessorGetters();
   genAttrGetters();
   genAttrSetters();
   genOptionalAttrRemovers();
   genBuilder();
+  genPopulateDefaultAttributes();
   genParser();
   genPrinter();
   genVerifier();
   genCustomVerifier();
   genCanonicalizerDecls();
   genFolderDecls();
   genTypeInterfaceMethods();
   genOpInterfaceMethods();
void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
   }
 
   // Result types
   SmallVector<std::string, 2> resultTypes(numResults, "operands[0].getType()");
   body << "  " << builderOpState << ".addTypes({"
        << llvm::join(resultTypes, ", ") << "});\n\n";
 }
 
+void OpEmitter::genPopulateDefaultAttributes() {
+  // All done if no attributes have default values.
+  if (llvm::all_of(op.getAttributes(), [](const NamedAttribute &named) {
+        return !named.attr.hasDefaultValue();
+      }))
+    return;
+
+  SmallVector<MethodParameter> paramList;
+  paramList.emplace_back("const ::mlir::RegisteredOperationName &", "opName");
+  paramList.emplace_back("::mlir::NamedAttrList &", "attributes");
+  auto *m = opClass.addStaticMethod("void", "populateDefaultAttrs", paramList);
+  ERROR_IF_PRUNED(m, "populateDefaultAttrs", op);
+  auto &body = m->body();
+  body.indent();
+
+  // Set default attributes that are unset.
+  body << "auto attrNames = opName.getAttributeNames();\n";
+  body << "::mlir::Builder " << odsBuilder
+       << "(attrNames.front().getContext());\n";
+  StringMap<int> attrIndex;
+  for (const auto &it : llvm::enumerate(emitHelper.getAttrMetadata())) {
+    attrIndex[it.value().first] = it.index();
+  }
+  for (const NamedAttribute &namedAttr : op.getAttributes()) {
+    auto &attr = namedAttr.attr;
+    if (!attr.hasDefaultValue())
+      continue;
+    auto index = attrIndex[namedAttr.name];
+    body << "if (!attributes.get(attrNames[" << index << "])) {\n";
+    FmtContext fctx;
+    fctx.withBuilder(odsBuilder);
+    std::string defaultValue = std::string(
+        tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
+    body.indent() << formatv(" attributes.append(attrNames[{0}], {1});\n",
+                             index, defaultValue);
+    body.unindent() << "}\n";
+  }
+}
+
 void OpEmitter::genInferredTypeCollectiveParamBuilder() {
   SmallVector<MethodParameter> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
   StringRef attributesDefaultValue = op.getNumVariadicRegions() ? "" : "{}";
   paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
                          "attributes", attributesDefaultValue);
void OpEmitter::buildParamList(SmallVectorImpl<MethodParameter> &paramList,
                                llvm::StringSet<> &inferredAttributes,
                                SmallVectorImpl<std::string> &resultTypeNames,
                                TypeParamKind typeParamKind,
                                AttrParamKind attrParamKind) {
   resultTypeNames.clear();
   auto numResults = op.getNumResults();
   resultTypeNames.reserve(numResults);
 
-  paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
+  paramList.emplace_back("::mlir::OpBuilder &", odsBuilder);
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
 
   switch (typeParamKind) {
   case TypeParamKind::None:
     break;
   case TypeParamKind::Separate: {
     // Add parameters for all return types
     for (int i = 0; i < numResults; ++i) {
auto emitAttrWithStorageType = [&](StringRef name, StringRef emitName,
     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(
           tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
       body << "  if (!attr)\n    attr = " << defaultValue << ";\n";
     }
-    body << "  return attr;\n";
+    body << "return attr;\n";
   };
 
   {
     auto *m = adaptor.addMethod("::mlir::DictionaryAttr", "getAttributes");
     ERROR_IF_PRUNED(m, "Adaptor::getAttributes", op);
     m->body() << "  return odsAttrs;";
   }
   for (auto &namedAttr : op.getAttributes()) {

mlir/unittests/IR/OperationSupportTest.cpp

 //===- OperationSupportTest.cpp - Operation support unit tests ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/OperationSupport.h"
+#include "../../test/lib/Dialect/Test/TestDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "gtest/gtest.h"
 
 using namespace mlir;
 using namespace mlir::detail;
ASSERT_FALSE(dup.hasValue());
     ++it;
     EXPECT_EQ(it->getName(), b.getStringAttr("zoo"));
     EXPECT_EQ(it->getValue(), b.getStringAttr("z"));
   }
 
   attrs.assign({});
   ASSERT_TRUE(attrs.empty());
 }
+
+TEST(OperandStorageTest, PopulateDefaultAttrs) {
+  MLIRContext context;
+  context.getOrLoadDialect<test::TestDialect>();
+  Builder builder(&context);
+
+  OpBuilder b(&context);
+  auto req1 = b.getI32IntegerAttr(10);
+  auto req2 = b.getI32IntegerAttr(60);
+  Operation *op = b.create<test::OpAttrMatch1>(b.getUnknownLoc(), req1, nullptr,
+                                               nullptr, req2);
+  EXPECT_EQ(op->getAttr("default_valued_attr"), nullptr);
+  op->populateDefaultAttrs();
+  auto opt = op->getAttr("default_valued_attr");
+  EXPECT_NE(opt, nullptr) << *op;
+
+  op->destroy();
+}
 } // namespace