[mlir] Add Float Attribute, Integer Attribute and Bool Attribute subclasses to python bindings.

[zhanghb97]

Summary

Based on PyAttribute and PyConcreteAttribute classes, this patch implements the bindings of Float Attribute, Integer Attribute and Bool Attribute subclasses.
This patch also defines the mlirFloatAttrDoubleGetChecked C API which is bound with the FloatAttr.get python method.

[stellaraccident]

Thanks!

mlir/include/mlir-c/StandardAttributes.h

97

Can you change this to something like: "if the type is not valid for a construction of a FloatAttr, returns a null MlirAttribute."

mlir/lib/Bindings/Python/IRModules.cpp

753

It is common enough that I feel we would benefit from a get_f32 and get_f64 that do not take a type and do not fail.

754

Maybe drop the _typed suffix?

789

Ditto on just get

815

Change the c++ type to bool. (Aside from being more correct, that will trigger important conversion rules on the python side for "truthy" value).

mlir/test/Bindings/Python/ir_attributes.py

143

Test with True, not 1

[zhanghb97]

mlir/lib/Bindings/Python/IRModules.cpp

753

I'd like to confirm that if we give the get_f32 and get_f64 methods, then what about the f16 and bf16 float type, and do we still need to give the default get method (It seems that get_f32, get_f64, get_f16, get_bf16 can cover all the usage)?

[zhanghb97]

• Modify the comment for mlirFloatAttrDoubleGetChecked.
• Drop the _typed suffix for FloatAttr and IntegerAttr get methods.
• Change the parameter type of BoolAttr.get method to bool.
• Add get_f32 and get_f64 methods to FloatAttr.

mlir/include/mlir-c/StandardAttributes.h

 /** Checks whether the given attribute is a floating point attribute. */
 int mlirAttributeIsAFloat(MlirAttribute attr);
 
 /** Creates a floating point attribute in the given context with the given
  * double value and double-precision FP semantics. */
 MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
                                      double value);
 
+/** Same as "mlirFloatAttrDoubleGet", but if the type is not valid for a
+ * construction of a FloatAttr, returns a null MlirAttribute. */
+MlirAttribute mlirFloatAttrDoubleGetChecked(MlirType type, double value,
+                                            MlirLocation loc);
+
 /** Returns the value stored in the given floating point attribute, interpreting
  * the value as double. */
 double mlirFloatAttrGetValueDouble(MlirAttribute attr);
 
 /*============================================================================*/
 /* Integer attribute.                                                         */
 /*============================================================================*/
 

mlir/lib/Bindings/Python/IRModules.cpp

static void bind(py::module &m) {
     cls.def(py::init<PyAttribute &>(), py::keep_alive<0, 1>());
     DerivedTy::bindDerived(cls);
   }
 
   /// Implemented by derived classes to add methods to the Python subclass.
   static void bindDerived(ClassTy &m) {}
 };
 
+/// Float Point Attribute subclass - FloatAttr.
+class PyFloatAttribute : public PyConcreteAttribute<PyFloatAttribute> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAFloat;
+  static constexpr const char *pyClassName = "FloatAttr";
+  using PyConcreteAttribute::PyConcreteAttribute;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        // TODO: Make the location optional and create a default location.
+        [](PyType &type, double value, PyLocation &loc) {
+          MlirAttribute attr =
+              mlirFloatAttrDoubleGetChecked(type.type, value, loc.loc);
+          // TODO: Rework error reporting once diagnostic engine is exposed
+          // in C API.
+          if (mlirAttributeIsNull(attr)) {
+            throw SetPyError(PyExc_ValueError,
+                             llvm::Twine("invalid '") +
+                                 py::repr(py::cast(type)).cast<std::string>() +
+                                 "' and expected floating point type.");
+          }
+          return PyFloatAttribute(type.getContext(), attr);
+        },
+        py::arg("type"), py::arg("value"), py::arg("loc"),
+        "Gets an uniqued float point attribute associated to a type");
+    c.def_static(
+        "get_f32",
+        [](PyMlirContext &context, double value) {
+          MlirAttribute attr = mlirFloatAttrDoubleGet(
+              context.get(), mlirF32TypeGet(context.get()), value);
+          return PyFloatAttribute(context.getRef(), attr);
+        },
+        py::arg("context"), py::arg("value"),
+        "Gets an uniqued float point attribute associated to a f32 type");
+    c.def_static(
+        "get_f64",
+        [](PyMlirContext &context, double value) {
+          MlirAttribute attr = mlirFloatAttrDoubleGet(
+              context.get(), mlirF64TypeGet(context.get()), value);
+          return PyFloatAttribute(context.getRef(), attr);
+        },
+        py::arg("context"), py::arg("value"),
+        "Gets an uniqued float point attribute associated to a f64 type");
+    c.def_property_readonly(
+        "value",
+        [](PyFloatAttribute &self) {
+          return mlirFloatAttrGetValueDouble(self.attr);
+        },
+        "Returns the value of the float point attribute");
+  }
+};
+
+/// Integer Attribute subclass - IntegerAttr.
+class PyIntegerAttribute : public PyConcreteAttribute<PyIntegerAttribute> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAInteger;
+  static constexpr const char *pyClassName = "IntegerAttr";
+  using PyConcreteAttribute::PyConcreteAttribute;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        [](PyType &type, int64_t value) {
+          MlirAttribute attr = mlirIntegerAttrGet(type.type, value);
+          return PyIntegerAttribute(type.getContext(), attr);
+        },
+        py::arg("type"), py::arg("value"),
+        "Gets an uniqued integer attribute associated to a type");
+    c.def_property_readonly(
+        "value",
+        [](PyIntegerAttribute &self) {
+          return mlirIntegerAttrGetValueInt(self.attr);
+        },
+        "Returns the value of the integer attribute");
+  }
+};
+
+/// Bool Attribute subclass - BoolAttr.
+class PyBoolAttribute : public PyConcreteAttribute<PyBoolAttribute> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirAttributeIsABool;
+  static constexpr const char *pyClassName = "BoolAttr";
+  using PyConcreteAttribute::PyConcreteAttribute;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        [](PyMlirContext &context, bool value) {
+          MlirAttribute attr = mlirBoolAttrGet(context.get(), value);
+          return PyBoolAttribute(context.getRef(), attr);
+        },
+        py::arg("context"), py::arg("value"), "Gets an uniqued bool attribute");
+    c.def_property_readonly(
+        "value",
+        [](PyBoolAttribute &self) { return mlirBoolAttrGetValue(self.attr); },
+        "Returns the value of the bool attribute");
+  }
+};
+
 class PyStringAttribute : public PyConcreteAttribute<PyStringAttribute> {
 public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAString;
   static constexpr const char *pyClassName = "StringAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
py::class_<PyNamedAttribute>(m, "NamedAttribute")
             auto contextRef = PyMlirContext::forContext(
                 mlirAttributeGetContext(self.namedAttr.attribute));
             return PyAttribute(std::move(contextRef), self.namedAttr.attribute);
           },
           py::keep_alive<0, 1>(),
           "The underlying generic attribute of the NamedAttribute binding");
 
   // Standard attribute bindings.
+  PyFloatAttribute::bind(m);
+  PyIntegerAttribute::bind(m);
+  PyBoolAttribute::bind(m);
   PyStringAttribute::bind(m);
 
   // Mapping of Type.
   py::class_<PyType>(m, "Type")
       .def("__eq__",
            [](PyType &self, py::object &other) {
              try {
                PyType otherType = other.cast<PyType>();

mlir/lib/CAPI/IR/StandardAttributes.cpp

int mlirAttributeIsAFloat(MlirAttribute attr) {
   return unwrap(attr).isa<FloatAttr>();
 }
 
 MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
                                      double value) {
   return wrap(FloatAttr::get(unwrap(type), value));
 }
 
+MlirAttribute mlirFloatAttrDoubleGetChecked(MlirType type, double value,
+                                            MlirLocation loc) {
+  return wrap(FloatAttr::getChecked(unwrap(type), value, unwrap(loc)));
+}
+
 double mlirFloatAttrGetValueDouble(MlirAttribute attr) {
   return unwrap(attr).cast<FloatAttr>().getValueAsDouble();
 }
 
 /*============================================================================*/
 /* Integer attribute.                                                         */
 /*============================================================================*/
 

mlir/test/Bindings/Python/ir_attributes.py

except ValueError as e:
     # CHECK: ValueError: Cannot cast attribute to StringAttr (from Attribute(1.000000e+00 : f64))
     print("ValueError:", e)
   else:
     print("Exception not produced")
 
 run(testStandardAttrCasts)
 
 
+# CHECK-LABEL: TEST: testFloatAttr
+def testFloatAttr():
+  ctx = mlir.ir.Context()
+  fattr = mlir.ir.FloatAttr(ctx.parse_attr("42.0 : f32"))
+  # CHECK: fattr value: 42.0
+  print("fattr value:", fattr.value)
+
+  # Test factory methods.
+  loc = ctx.get_unknown_location()
+  # CHECK: default_get: 4.200000e+01 : f32
+  print("default_get:", mlir.ir.FloatAttr.get(
+      mlir.ir.F32Type(ctx), 42.0, loc))
+  # CHECK: f32_get: 4.200000e+01 : f32
+  print("f32_get:", mlir.ir.FloatAttr.get_f32(ctx, 42.0))
+  # CHECK: f64_get: 4.200000e+01 : f64
+  print("f64_get:", mlir.ir.FloatAttr.get_f64(ctx, 42.0))
+  try:
+    fattr_invalid = mlir.ir.FloatAttr.get(
+        mlir.ir.IntegerType.get_signless(ctx, 32), 42, loc)
+  except ValueError as e:
+    # CHECK: invalid 'Type(i32)' and expected floating point type.
+    print(e)
+  else:
+    print("Exception not produced")
+
+run(testFloatAttr)
+
+
+# CHECK-LABEL: TEST: testIntegerAttr
+def testIntegerAttr():
+  ctx = mlir.ir.Context()
+  iattr = mlir.ir.IntegerAttr(ctx.parse_attr("42"))
+  # CHECK: iattr value: 42
+  print("iattr value:", iattr.value)
+
+  # Test factory methods.
+  # CHECK: default_get: 42 : i32
+  print("default_get:", mlir.ir.IntegerAttr.get(
+      mlir.ir.IntegerType.get_signless(ctx, 32), 42))
+
+run(testIntegerAttr)
+
+
+# CHECK-LABEL: TEST: testBoolAttr
+def testBoolAttr():
+  ctx = mlir.ir.Context()
+  battr = mlir.ir.BoolAttr(ctx.parse_attr("true"))
+  # CHECK: iattr value: 1
+  print("iattr value:", battr.value)
+
+  # Test factory methods.
+  # CHECK: default_get: true
+  print("default_get:", mlir.ir.BoolAttr.get(ctx, True))
+
+run(testBoolAttr)
+
+
 # CHECK-LABEL: TEST: testStringAttr
 def testStringAttr():
   ctx = mlir.ir.Context()
   sattr = mlir.ir.StringAttr(ctx.parse_attr('"stringattr"'))
   # CHECK: sattr value: stringattr
   print("sattr value:", sattr.value)
 
   # Test factory methods.