[mlir] Add basic support for attributes in ODS-generated Python bindings

[ftynse]

Summary

In ODS, attributes of an operation can be provided as a part of the "arguments"
field, together with operands. Such attributes are accepted by the op builder
and have accessors generated.

Implement similar functionality for ODS-generated op-specific Python bindings:
the __init__ method now accepts arguments together with operands, in the same
order as in the ODS arguments field; the instance properties are introduced
to OpView classes to access the attributes.

This initial implementation accepts and returns instances of the corresponding
attribute class, and not the underlying values since the mapping scheme of the
value types between C++, C and Python is not yet clear. Default-valued
attributes are not supported as that would require Python to be able to parse
C++ literals.

Since attributes in ODS are tightely related to the actual C++ type system,
provide a separate Tablegen file with the mapping between ODS storage type for
attributes (typically, the underlying C++ attribute class), and the
corresponding class name. So far, this might look unnecessary since all names
match exactly, but this is not necessarily the cases for non-standard,
out-of-tree attributes, which may also be placed in non-default namespaces or
Python modules. This also allows out-of-tree users to generate Python bindings
without having to modify the bindings generator itself. Storage type was
preferred over the Tablegen "def" of the attribute class because ODS
essentially encodes attribute _constraints_ rather than classes, e.g. there may
be many Tablegen "def"s in the ODS that correspond to the same attribute type
with additional constraints

The presence of the explicit mapping requires the change in the .td file
structure: instead of just calling the bindings generator directly on the main
ODS file of the dialect, it becomes necessary to create a new file that
includes the main ODS file of the dialect and provides the mapping for
attribute types. Arguably, this approach offers better separability of the
Python bindings in the build system as the main dialect no longer needs to know
that it is being processed by the bindings generator.

[ftynse]

Simplify cmake further

[ftynse]

Customize handling of unit attributes

[stellaraccident]

This is quite slick. A couple of nits.

mlir/lib/Bindings/Python/Attributes.td

26

Are these relative to mlir.ir if unqualified?

mlir/test/mlir-tblgen/op-python-bindings.td

121

Valid? You qualify other things with _ir. but not the Location class.

I can't see the whole file yet so leaving a comment now. Also some other instances of this (IntegerAttr, FloatAttr, below).

159

I think we can add a helper for this. Something like mlir.ir._defaultLocContext that can take a None Location and do the right thing. (for a followup).

[ftynse]

Address review.

[ftynse]

mlir/lib/Bindings/Python/Attributes.td

26

Good point. I added an explicit qualification with _ir. for now. We will have to figure out the story for dialect-specific attributes, presumably import definitions into the generated file somehow.

mlir/test/mlir-tblgen/op-python-bindings.td

159

Ack.

mlir/CMakeLists.txt

 include_directories( "include")
 include_directories( ${MLIR_INCLUDE_DIR})
 
 # Adding tools/mlir-tblgen here as calling add_tablegen sets some variables like
 # MLIR_TABLEGEN_EXE in PARENT_SCOPE which gets lost if that folder is included
 # from another directory like tools
 add_subdirectory(tools/mlir-tblgen)
 
-# Create an anchor target that will depend on dialect-specific op bindings.
-if (MLIR_BINDINGS_PYTHON_ENABLED)
-  add_custom_target(MLIRBindingsPythonIncGen)
-  include(AddMLIRPythonExtension)
-endif()
-
 add_subdirectory(include/mlir)
 add_subdirectory(lib)
 # C API needs all dialects for registration, but should be built before tests.
 add_subdirectory(lib/CAPI)
 if (MLIR_INCLUDE_TESTS)
   add_definitions(-DMLIR_INCLUDE_TESTS)
   add_subdirectory(unittests)
   add_subdirectory(test)

mlir/cmake/modules/AddMLIRPythonExtension.cmake

if (NOT LLVM_ENABLE_IDE)
     add_llvm_install_targets(
       install-${libname}
       DEPENDS ${libname}
       COMPONENT ${libname})
   endif()
 
 endfunction()
 
-function(add_mlir_dialect_python_bindings filename dialectname)
+function(add_mlir_dialect_python_bindings tblgen_target filename dialectname)
   set(LLVM_TARGET_DEFINITIONS ${filename})
   mlir_tablegen("${dialectname}.py" -gen-python-op-bindings
                 -bind-dialect=${dialectname})
-  if (${ARGC} GREATER 2)
-    set(suffix ${ARGV2})
-  else()
-    get_filename_component(suffix ${filename} NAME_WE)
-  endif()
-  set(tblgen_target "MLIRBindingsPython${suffix}")
   add_public_tablegen_target(${tblgen_target})
 
   add_custom_command(
     TARGET ${tblgen_target} POST_BUILD
     COMMENT "Copying generated python source \"dialects/${dialectname}.py\""
     COMMAND "${CMAKE_COMMAND}" -E copy_if_different
       "${CMAKE_CURRENT_BINARY_DIR}/${dialectname}.py"
       "${PROJECT_BINARY_DIR}/python/mlir/dialects/${dialectname}.py")
-  add_dependencies(MLIRBindingsPythonIncGen ${tblgen_target})
 endfunction()
 

mlir/include/mlir/Dialect/StandardOps/IR/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
 mlir_tablegen(OpsDialect.h.inc -gen-dialect-decls)
 mlir_tablegen(OpsEnums.h.inc -gen-enum-decls)
 mlir_tablegen(OpsEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRStandardOpsIncGen)
 
 add_mlir_doc(Ops -gen-op-doc StandardOps Dialects/)
-
-if (MLIR_BINDINGS_PYTHON_ENABLED)
-  add_mlir_dialect_python_bindings(Ops.td std StandardOps)
-endif()

mlir/lib/Bindings/Python/Attributes.td

+//===-- Attributes.td - Attribute mapping for Python -------*- tablegen -*-===//
+//
+// 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 defines the mapping between MLIR ODS attributes and the corresponding
+// Python binding classes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef PYTHON_BINDINGS_ATTRIBUTES
+#define PYTHON_BINDINGS_ATTRIBUTES
+
+// A mapping between the attribute storage type and the corresponding Python
+// type. There is not necessarily a 1-1 match for non-standard attributes.
+class PythonAttr<string c, string p> {
+  string cppStorageType = c;
+  string pythonType = p;
+}
+
+// Mappings between supported standard attribtues and Python types.
+def : PythonAttr<"::mlir::Attribute", "_ir.Attribute">;
+def : PythonAttr<"::mlir::BoolAttr", "_ir.BoolAttr">;
+def : PythonAttr<"::mlir::IntegerAttr", "_ir.IntegerAttr">;
+def : PythonAttr<"::mlir::FloatAttr", "_ir.FloatAttr">;
+def : PythonAttr<"::mlir::StringAttr", "_ir.StringAttr">;
+def : PythonAttr<"::mlir::DenseElementsAttr", "_ir.DenseElementsAttr">;
+def : PythonAttr<"::mlir::DenseIntElementsAttr", "_ir.DenseIntElementsAttr">;
+def : PythonAttr<"::mlir::DenseFPElementsAttr", "_ir.DenseFPElementsAttr">;
+
+#endif

mlir/lib/Bindings/Python/CMakeLists.txt

 include(AddMLIRPythonExtension)
 add_custom_target(MLIRBindingsPythonExtension)
+
+################################################################################
+# Generate dialect-specific bindings.
+################################################################################
+
+add_mlir_dialect_python_bindings(MLIRBindingsPythonStandardOps
+  StandardOps.td
+  std)
+add_dependencies(MLIRBindingsPythonExtension MLIRBindingsPythonStandardOps)
+
 ################################################################################
 # Copy python source tree.
 ################################################################################
 
 set(PY_SRC_FILES
   mlir/__init__.py
   mlir/_dlloader.py
   mlir/ir.py
   mlir/dialects/__init__.py
   mlir/ir.py
   mlir/passmanager.py
   mlir/transforms/__init__.py
 )
 
 add_custom_target(MLIRBindingsPythonSources ALL
   DEPENDS ${PY_SRC_FILES}
 )
 add_dependencies(MLIRBindingsPythonExtension MLIRBindingsPythonSources)
 
-add_dependencies(MLIRBindingsPythonExtension MLIRBindingsPythonIncGen)
-
 foreach(PY_SRC_FILE ${PY_SRC_FILES})
   set(PY_DEST_FILE "${PROJECT_BINARY_DIR}/python/${PY_SRC_FILE}")
   add_custom_command(
     TARGET MLIRBindingsPythonSources PRE_BUILD
     COMMENT "Copying python source ${PY_SRC_FILE} -> ${PY_DEST_FILE}"
     DEPENDS "${PY_SRC_FILE}"
     COMMAND "${CMAKE_COMMAND}" -E copy_if_different
         "${CMAKE_CURRENT_SOURCE_DIR}/${PY_SRC_FILE}" "${PY_DEST_FILE}"

mlir/lib/Bindings/Python/IRModules.cpp

MlirNamedAttribute namedAttr =
         mlirOperationGetAttribute(operation->get(), index);
     return PyNamedAttribute(namedAttr.attribute, std::string(namedAttr.name));
   }
 
   intptr_t dunderLen() {
     return mlirOperationGetNumAttributes(operation->get());
   }
 
+  bool dunderContains(const std::string &name) {
+    return !mlirAttributeIsNull(
+        mlirOperationGetAttributeByName(operation->get(), name.c_str()));
+  }
+
   static void bind(py::module &m) {
     py::class_<PyOpAttributeMap>(m, "OpAttributeMap")
+        .def("__contains__", &PyOpAttributeMap::dunderContains)
         .def("__len__", &PyOpAttributeMap::dunderLen)
         .def("__getitem__", &PyOpAttributeMap::dunderGetItemNamed)
         .def("__getitem__", &PyOpAttributeMap::dunderGetItemIndexed);
   }
 
 private:
   PyOperationRef operation;
 };
py::float_ dunderGetItem(intptr_t pos) {
     throw SetPyError(PyExc_TypeError, "Unsupported floating-point type");
   }
 
   static void bindDerived(ClassTy &c) {
     c.def("__getitem__", &PyDenseFPElementsAttribute::dunderGetItem);
   }
 };
 
+/// Unit Attribute subclass. Unit attributes don't have values.
+class PyUnitAttribute : public PyConcreteAttribute<PyUnitAttribute> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAUnit;
+  static constexpr const char *pyClassName = "UnitAttr";
+  using PyConcreteAttribute::PyConcreteAttribute;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        [](DefaultingPyMlirContext context) {
+          return PyUnitAttribute(context->getRef(),
+                                 mlirUnitAttrGet(context->get()));
+        },
+        py::arg("context") = py::none(), "Create a Unit attribute.");
+  }
+};
+
 } // namespace
 
 //------------------------------------------------------------------------------
 // Standard type subclasses.
 //------------------------------------------------------------------------------
 
 namespace {
 
void mlir::python::populateIRSubmodule(py::module &m) {
   // Standard attribute bindings.
   PyFloatAttribute::bind(m);
   PyIntegerAttribute::bind(m);
   PyBoolAttribute::bind(m);
   PyStringAttribute::bind(m);
   PyDenseElementsAttribute::bind(m);
   PyDenseIntElementsAttribute::bind(m);
   PyDenseFPElementsAttribute::bind(m);
+  PyUnitAttribute::bind(m);
 
   //----------------------------------------------------------------------------
   // Mapping of PyType.
   //----------------------------------------------------------------------------
   py::class_<PyType>(m, "Type")
       .def_static(
           "parse",
           [](std::string typeSpec, DefaultingPyMlirContext context) {

mlir/lib/Bindings/Python/StandardOps.td

+//===-- StandardOps.td - Entry point for StandardOps bind --*- tablegen -*-===//
+//
+// 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 is the main file from which the Python bindings for the Standard
+// dialect are generated.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef PYTHON_BINDINGS_STANDARD_OPS
+#define PYTHON_BINDINGS_STANDARD_OPS
+
+include "mlir/Dialect/StandardOps/IR/Ops.td"
+include "Attributes.td"
+
+#endif

mlir/lib/TableGen/Operator.cpp

 Operator::arg_iterator Operator::arg_end() const { return arguments.end(); }
 
 Operator::arg_range Operator::getArgs() const {
   return {arg_begin(), arg_end()};
 }
 
 StringRef Operator::getArgName(int index) const {
   DagInit *argumentValues = def.getValueAsDag("arguments");
-  return argumentValues->getArgName(index)->getValue();
+  return argumentValues->getArgNameStr(index);
 }
 
 auto Operator::getArgDecorators(int index) const -> var_decorator_range {
   Record *arg =
       cast<DefInit>(def.getValueAsDag("arguments")->getArg(index))->getDef();
   if (!arg->isSubClassOf("OpVariable"))
     return var_decorator_range(nullptr, nullptr);
   return *arg->getValueAsListInit("decorators");

mlir/test/mlir-tblgen/op-python-bindings.td

-// RUN: mlir-tblgen -gen-python-op-bindings -bind-dialect=test -I %S/../../include %s | FileCheck %s
+// RUN: mlir-tblgen -gen-python-op-bindings -bind-dialect=test -I %S/../../include -I %S/../../lib/Bindings/Python %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
+include "Attributes.td"
 
 // CHECK: @_cext.register_dialect
 // CHECK: class _Dialect(_ir.Dialect):
   // CHECK: DIALECT_NAMESPACE = "test"
   // CHECK: pass
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "Test";
def AttrSizedResultsOp : TestOp<"attr_sized_results",
   // CHECK:   result_range = _segmented_accessor(
   // CHECK:       self.operation.results,
   // CHECK:       self.operation.attributes["result_segment_sizes"], 2)
   // CHECK:   return result_range
   let results = (outs Optional<AnyType>:$variadic1, AnyType:$non_variadic,
                  Optional<AnyType>:$variadic2);
 }
 
+
+// CHECK: @_cext.register_operation(_Dialect)
+// CHECK: class AttributedOp(_ir.OpView):
+// CHECK-LABEL: OPERATION_NAME = "test.attributed_op"
+def AttributedOp : TestOp<"attributed_op"> {
+  // CHECK: def __init__(self, i32attr, optionalF32Attr, unitAttr, in_, loc=None, ip=None):
+  // CHECK:   operands = []
+  // CHECK:   results = []
+  // CHECK:   attributes = {}
+  // CHECK:   attributes["i32attr"] = i32attr
+  // CHECK:   if optionalF32Attr is not None: attributes["optionalF32Attr"] = optionalF32Attr
+  // CHECK:   if bool(unitAttr): attributes["unitAttr"] = _ir.UnitAttr.get(
+  // CHECK:     _ir.Location.current.context if loc is None else loc.context)
+  // CHECK:   attributes["in"] = in_
+  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:     "test.attributed_op", attributes=attributes, operands=operands, results=results,
+  // CHECK:     loc=loc, ip=ip))
+
+  // CHECK: @property
+  // CHECK: def i32attr(self):
+  // CHECK:   return _ir.IntegerAttr(self.operation.attributes["i32attr"])
+
+  // CHECK: @property
+  // CHECK: def optionalF32Attr(self):
+  // CHECK:   if "optionalF32Attr" not in self.operation.attributes:
+  // CHECK:     return None
+  // CHECK:   return _ir.FloatAttr(self.operation.attributes["optionalF32Attr"])
+
+  // CHECK: @property
+  // CHECK: def unitAttr(self):
+  // CHECK:   return "unitAttr" in self.operation.attributes
+
+  // CHECK: @property
+  // CHECK: def in_(self):
+  // CHECK:   return _ir.IntegerAttr(self.operation.attributes["in"])
+  let arguments = (ins I32Attr:$i32attr, OptionalAttr<F32Attr>:$optionalF32Attr,
+                   UnitAttr:$unitAttr, I32Attr:$in);
+}
+
+// CHECK: @_cext.register_operation(_Dialect)
+// CHECK: class AttributedOpWithOperands(_ir.OpView):
+// CHECK-LABEL: OPERATION_NAME = "test.attributed_op_with_operands"
+def AttributedOpWithOperands : TestOp<"attributed_op_with_operands"> {
+  // CHECK: def __init__(self, _gen_arg_0, in_, _gen_arg_2, is_, loc=None, ip=None):
+  // CHECK:   operands = []
+  // CHECK:   results = []
+  // CHECK:   attributes = {}
+  // CHECK:   operands.append(_gen_arg_0)
+  // CHECK:   operands.append(_gen_arg_2)
+  // CHECK:   if bool(in_): attributes["in"] = _ir.UnitAttr.get(
+  // CHECK:     _ir.Location.current.context if loc is None else loc.context)
+  // CHECK:   if is_ is not None: attributes["is"] = is_
+  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:     "test.attributed_op_with_operands", attributes=attributes, operands=operands, results=results,
+  // CHECK:     loc=loc, ip=ip))
+
+  // CHECK: @property
+  // CHECK: def in_(self):
+  // CHECK:   return "in" in self.operation.attributes
+
+  // CHECK: @property
+  // CHECK: def is_(self):
+  // CHECK:   if "is" not in self.operation.attributes:
+  // CHECK:     return None
+  // CHECK:   return _ir.FloatAttr(self.operation.attributes["is"])
+  let arguments = (ins I32, UnitAttr:$in, F32, OptionalAttr<F32Attr>:$is);
+}
+
+
 // CHECK: @_cext.register_operation(_Dialect)
 // CHECK: class EmptyOp(_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.empty"
 def EmptyOp : TestOp<"empty">;
   // CHECK: def __init__(self, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

 )Py";
 
 /// Template for a suffix when accessing an optional element in the
 /// attribute-sized case:
 ///   {0} is either 'operand' or 'result';
 constexpr const char *opVariadicSegmentOptionalTrailingTemplate =
     R"Py([0] if len({0}_range) > 0 else None)Py";
 
+/// Template for an operation attribute getter:
+///   {0} is the name of the attribute sanitized for Python;
+///   {1} is the Python type of the attribute;
+///   {2} os the original name of the attribute.
+constexpr const char *attributeGetterTemplate = R"Py(
+  @property
+  def {0}(self):
+    return {1}(self.operation.attributes["{2}"])
+)Py";
+
+/// Template for an optional operation attribute getter:
+///   {0} is the name of the attribute sanitized for Python;
+///   {1} is the Python type of the attribute;
+///   {2} is the original name of the attribute.
+constexpr const char *optionalAttributeGetterTemplate = R"Py(
+  @property
+  def {0}(self):
+    if "{2}" not in self.operation.attributes:
+      return None
+    return {1}(self.operation.attributes["{2}"])
+)Py";
+
+/// Template for a accessing a unit operation attribute, returns True of the
+/// unit attribute is present, False otherwise (unit attributes have meaning
+/// by mere presence):
+///    {0} is the name of the attribute sanitized for Python,
+///    {1} is the original name of the attribute.
+constexpr const char *unitAttributeGetterTemplate = R"Py(
+  @property
+  def {0}(self):
+    return "{1}" in self.operation.attributes
+)Py";
+
 static llvm::cl::OptionCategory
     clOpPythonBindingCat("Options for -gen-python-op-bindings");
 
 static llvm::cl::opt<std::string>
     clDialectName("bind-dialect",
                   llvm::cl::desc("The dialect to run the generator for"),
                   llvm::cl::init(""), llvm::cl::cat(clOpPythonBindingCat));
 
+using AttributeClasses = DenseMap<StringRef, StringRef>;
+
 /// Checks whether `str` is a Python keyword.
 static bool isPythonKeyword(StringRef str) {
   static llvm::StringSet<> keywords(
       {"and",   "as",     "assert",   "break", "class",  "continue",
        "def",   "del",    "elif",     "else",  "except", "finally",
        "for",   "from",   "global",   "if",    "import", "in",
        "is",    "lambda", "nonlocal", "not",   "or",     "pass",
        "raise", "return", "try",      "while", "with",   "yield"});

 static const NamedTypeConstraint &getOperand(const Operator &op, int i) {
   return op.getOperand(i);
 }
 static int getNumResults(const Operator &op) { return op.getNumResults(); }
 static const NamedTypeConstraint &getResult(const Operator &op, int i) {
   return op.getResult(i);
 }
 
-/// Emits accessor to Op operands.
+/// Emits accessors to Op operands.
 static void emitOperandAccessors(const Operator &op, raw_ostream &os) {
   auto getNumVariadic = [](const Operator &oper) {
     return oper.getNumVariableLengthOperands();
   };
   emitElementAccessors(op, os, "operand", getNumVariadic, getNumOperands,
                        getOperand);
 }
 
-/// Emits access or Op results.
+/// Emits accessors Op results.
 static void emitResultAccessors(const Operator &op, raw_ostream &os) {
   auto getNumVariadic = [](const Operator &oper) {
     return oper.getNumVariableLengthResults();
   };
   emitElementAccessors(op, os, "result", getNumVariadic, getNumResults,
                        getResult);
 }
 
+/// Emits accessors to Op attributes.
+static void emitAttributeAccessors(const Operator &op,
+                                   const AttributeClasses &attributeClasses,
+                                   raw_ostream &os) {
+  for (const auto &namedAttr : op.getAttributes()) {
+    // Skip "derived" attributes because they are just C++ functions that we
+    // don't currently expose.
+    if (namedAttr.attr.isDerivedAttr())
+      continue;
+
+    if (namedAttr.name.empty())
+      continue;
+
+    // Unit attributes are handled specially.
+    if (namedAttr.attr.getStorageType().trim().equals("::mlir::UnitAttr")) {
+      os << llvm::formatv(unitAttributeGetterTemplate,
+                          sanitizeName(namedAttr.name), namedAttr.name);
+      continue;
+    }
+
+    // Other kinds of attributes need a mapping to a Python type.
+    if (!attributeClasses.count(namedAttr.attr.getStorageType().trim()))
+      continue;
+
+    os << llvm::formatv(
+        namedAttr.attr.isOptional() ? optionalAttributeGetterTemplate
+                                    : attributeGetterTemplate,
+        sanitizeName(namedAttr.name),
+        attributeClasses.lookup(namedAttr.attr.getStorageType()),
+        namedAttr.name);
+  }
+}
+
 /// Template for the default auto-generated builder.
 ///   {0} is the operation name;
 ///   {1} is a comma-separated list of builder arguments, including the trailing
 ///       `loc` and `ip`;
 ///   {2} is the code populating `operands`, `results` and `attributes` fields.
 constexpr const char *initTemplate = R"Py(
   def __init__(self, {1}):
     operands = []
constexpr const char *optionalSegmentTemplate =
     "{0}_segment_sizes.append(0 if {1} is None else 1)";
 
 /// Template for appending the length of a variadic group to the segment sizes.
 ///   {0} is either 'operand' or 'result';
 ///   {1} is the field name.
 constexpr const char *variadicSegmentTemplate =
     "{0}_segment_sizes.append(len({1}))";
 
-/// Populates `builderArgs` with the list of `__init__` arguments that
-/// correspond to either operands or results of `op`, and `builderLines` with
-/// additional lines that are required in the builder. `kind` must be either
-/// "operand" or "result". `unnamedTemplate` is used to generate names for
-/// operands or results that don't have the name in ODS.
-static void populateBuilderLines(
-    const Operator &op, const char *kind, const char *unnamedTemplate,
+/// Template for setting an attribute in the operation builder.
+///   {0} is the attribute name;
+///   {1} is the builder argument name.
+constexpr const char *initAttributeTemplate = R"Py(attributes["{0}"] = {1})Py";
+
+/// Template for setting an optional attribute in the operation builder.
+///   {0} is the attribute name;
+///   {1} is the builder argument name.
+constexpr const char *initOptionalAttributeTemplate =
+    R"Py(if {1} is not None: attributes["{0}"] = {1})Py";
+
+constexpr const char *initUnitAttributeTemplate =
+    R"Py(if bool({1}): attributes["{0}"] = _ir.UnitAttr.get(
+      _ir.Location.current.context if loc is None else loc.context))Py";
+
+/// Populates `builderArgs` with the Python-compatible names of builder function
+/// arguments, first the results, then the intermixed attributes and operands in
+/// the same order as they appear in the `arguments` field of the op definition.
+/// Additionally, `operandNames` is populated with names of operands in their
+/// order of appearance.
+static void
+populateBuilderArgs(const Operator &op,
                     llvm::SmallVectorImpl<std::string> &builderArgs,
+                    llvm::SmallVectorImpl<std::string> &operandNames) {
+  for (int i = 0, e = op.getNumResults(); i < e; ++i) {
+    std::string name = op.getResultName(i).str();
+    if (name.empty())
+      name = llvm::formatv("_gen_res_{0}", i);
+    name = sanitizeName(name);
+    builderArgs.push_back(name);
+  }
+  for (int i = 0, e = op.getNumArgs(); i < e; ++i) {
+    std::string name = op.getArgName(i).str();
+    if (name.empty())
+      name = llvm::formatv("_gen_arg_{0}", i);
+    name = sanitizeName(name);
+    builderArgs.push_back(name);
+    if (!op.getArg(i).is<NamedAttribute *>())
+      operandNames.push_back(name);
+  }
+}
+
+/// Populates `builderLines` with additional lines that are required in the
+/// builder to set up operation attributes. `argNames` is expected to contain
+/// the names of builder arguments that correspond to op arguments, i.e. to the
+/// operands and attributes in the same order as they appear in the `arguments`
+/// field.
+static void
+populateBuilderLinesAttr(const Operator &op,
+                         llvm::ArrayRef<std::string> argNames,
+                         llvm::SmallVectorImpl<std::string> &builderLines) {
+  for (int i = 0, e = op.getNumArgs(); i < e; ++i) {
+    Argument arg = op.getArg(i);
+    auto *attribute = arg.dyn_cast<NamedAttribute *>();
+    if (!attribute)
+      continue;
+
+    // Unit attributes are handled specially.
+    if (attribute->attr.getStorageType().trim().equals("::mlir::UnitAttr")) {
+      builderLines.push_back(llvm::formatv(initUnitAttributeTemplate,
+                                           attribute->name, argNames[i]));
+      continue;
+    }
+
+    builderLines.push_back(llvm::formatv(attribute->attr.isOptional()
+                                             ? initOptionalAttributeTemplate
+                                             : initAttributeTemplate,
+                                         attribute->name, argNames[i]));
+  }
+}
+
+/// Populates `builderLines` with additional lines that are required in the
+/// builder. `kind` must be either "operand" or "result". `names` contains the
+/// names of init arguments that correspond to the elements.
+static void populateBuilderLines(
+    const Operator &op, const char *kind, llvm::ArrayRef<std::string> names,
     llvm::SmallVectorImpl<std::string> &builderLines,
     llvm::function_ref<int(const Operator &)> getNumElements,
     llvm::function_ref<const NamedTypeConstraint &(const Operator &, int)>
         getElement) {
   // The segment sizes buffer only has to be populated if there attr-sized
   // segments trait is present.
   bool includeSegments = op.getTrait(attrSizedTraitForKind(kind)) != nullptr;
   if (includeSegments)
     builderLines.push_back(llvm::formatv(segmentDeclarationTemplate, kind));
 
   // For each element, find or generate a name.
   for (int i = 0, e = getNumElements(op); i < e; ++i) {
     const NamedTypeConstraint &element = getElement(op, i);
-    std::string name = element.name.str();
-    if (name.empty())
-      name = llvm::formatv(unnamedTemplate, i).str();
-    name = sanitizeName(name);
-    builderArgs.push_back(name);
+    std::string name = names[i];
 
     // Choose the formatting string based on the element kind.
     llvm::StringRef formatString, segmentFormatString;
     if (!element.isVariableLength()) {
       formatString = singleElementAppendTemplate;
       segmentFormatString = singleElementSegmentTemplate;
     } else if (element.isOptional()) {
       formatString = optionalAppendTemplate;
static void populateBuilderLines(
 
   if (includeSegments)
     builderLines.push_back(llvm::formatv(segmentAttributeTemplate, kind));
 }
 
 /// Emits a default builder constructing an operation from the list of its
 /// result types, followed by a list of its operands.
 static void emitDefaultOpBuilder(const Operator &op, raw_ostream &os) {
-  // TODO: support attribute types.
-  if (op.getNumNativeAttributes() != 0)
-    return;
-
   // If we are asked to skip default builders, comply.
   if (op.skipDefaultBuilders())
     return;
 
   llvm::SmallVector<std::string, 8> builderArgs;
   llvm::SmallVector<std::string, 8> builderLines;
-  builderArgs.reserve(op.getNumOperands() + op.getNumResults());
-  populateBuilderLines(op, "result", "_gen_res_{0}", builderArgs, builderLines,
-                       getNumResults, getResult);
-  populateBuilderLines(op, "operand", "_gen_arg_{0}", builderArgs, builderLines,
+  llvm::SmallVector<std::string, 4> operandArgNames;
+  builderArgs.reserve(op.getNumOperands() + op.getNumResults() +
+                      op.getNumNativeAttributes());
+  populateBuilderArgs(op, builderArgs, operandArgNames);
+  populateBuilderLines(
+      op, "result",
+      llvm::makeArrayRef(builderArgs).take_front(op.getNumResults()),
+      builderLines, getNumResults, getResult);
+  populateBuilderLines(op, "operand", operandArgNames, builderLines,
                        getNumOperands, getOperand);
+  populateBuilderLinesAttr(
+      op, llvm::makeArrayRef(builderArgs).drop_front(op.getNumResults()),
+      builderLines);
 
   builderArgs.push_back("loc=None");
   builderArgs.push_back("ip=None");
   os << llvm::formatv(initTemplate, op.getOperationName(),
                       llvm::join(builderArgs, ", "),
                       llvm::join(builderLines, "\n    "));
 }
 
+static void constructAttributeMapping(const llvm::RecordKeeper &records,
+                                      AttributeClasses &attributeClasses) {
+  for (const llvm::Record *rec :
+       records.getAllDerivedDefinitions("PythonAttr")) {
+    attributeClasses.try_emplace(rec->getValueAsString("cppStorageType").trim(),
+                                 rec->getValueAsString("pythonType").trim());
+  }
+}
+
 /// Emits bindings for a specific Op to the given output stream.
-static void emitOpBindings(const Operator &op, raw_ostream &os) {
+static void emitOpBindings(const Operator &op,
+                           const AttributeClasses &attributeClasses,
+                           raw_ostream &os) {
   os << llvm::formatv(opClassTemplate, op.getCppClassName(),
                       op.getOperationName());
   emitDefaultOpBuilder(op, os);
   emitOperandAccessors(op, os);
+  emitAttributeAccessors(op, attributeClasses, os);
   emitResultAccessors(op, os);
 }
 
 /// Emits bindings for the dialect specified in the command line, including file
 /// headers and utilities. Returns `false` on success to comply with Tablegen
 /// registration requirements.
 static bool emitAllOps(const llvm::RecordKeeper &records, raw_ostream &os) {
   if (clDialectName.empty())
     llvm::PrintFatalError("dialect name not provided");
 
+  AttributeClasses attributeClasses;
+  constructAttributeMapping(records, attributeClasses);
+
   os << fileHeader;
   os << llvm::formatv(dialectClassTemplate, clDialectName.getValue());
   for (const llvm::Record *rec : records.getAllDerivedDefinitions("Op")) {
     Operator op(rec);
     if (op.getDialectName() == clDialectName.getValue())
-      emitOpBindings(op, os);
+      emitOpBindings(op, attributeClasses, os);
   }
   return false;
 }
 
 static GenRegistration
     genPythonBindings("gen-python-op-bindings",
                       "Generate Python bindings for MLIR Ops", &emitAllOps);