[MLIR][python bindings] Add more basic AttrBuilder for _ops_gen.py files

[HarmonyHu]

Summary

Add more attribute builders, such as "F32Attr", "F64Attr" and "F64ArrayAttr", which are useful to create operations by python bindings. For example, tosa.clamp in _tosa_ops_gen.py need 'F32Attr'.

[ftynse]

Can we add some tests for these?

[HarmonyHu]

Add unit test for attribute builders.
Please help me to commit this patch if accepted, as it's my first contribution to LLVM.

mlir/python/mlir/ir.py

 
 
 @register_attribute_builder("IndexAttr")
 def _indexAttr(x, context):
   return IntegerAttr.get(IndexType.get(context=context), x)
 
 
 @register_attribute_builder("I16Attr")
-def _i32Attr(x, context):
+def _i16Attr(x, context):
   return IntegerAttr.get(IntegerType.get_signless(16, context=context), x)
 
-
 @register_attribute_builder("I32Attr")
 def _i32Attr(x, context):
   return IntegerAttr.get(IntegerType.get_signless(32, context=context), x)
 
-
 @register_attribute_builder("I64Attr")
 def _i64Attr(x, context):
   return IntegerAttr.get(IntegerType.get_signless(64, context=context), x)
 
+@register_attribute_builder("SI16Attr")
+def _si16Attr(x, context):
+  return IntegerAttr.get(IntegerType.get_signed(16, context=context), x)
+
+@register_attribute_builder("SI32Attr")
+def _si32Attr(x, context):
+  return IntegerAttr.get(IntegerType.get_signed(32, context=context), x)
+
+@register_attribute_builder("F32Attr")
+def _f32Attr(x, context):
+  return FloatAttr.get_f32(x, context=context)
+
+@register_attribute_builder("F64Attr")
+def _f64Attr(x, context):
+  return FloatAttr.get_f64(x, context=context)
 
 @register_attribute_builder("StrAttr")
 def _stringAttr(x, context):
   return StringAttr.get(x, context=context)
 
-
-@register_attribute_builder("SymbolNameAttr")
-def _symbolNameAttr(x, context):
-  return StringAttr.get(x, context=context)
-
-
-@register_attribute_builder("SymbolRefAttr")
-def _symbolRefAttr(x, context):
-  return FlatSymbolRefAttr.get(x, context=context)
-
-
 @register_attribute_builder("ArrayAttr")
 def _arrayAttr(x, context):
   return ArrayAttr.get(x, context=context)
 
+@register_attribute_builder("I32ArrayAttr")
+def _i32ArrayAttr(x, context):
+  return ArrayAttr.get([_i32Attr(v, context) for v in x])
 
 @register_attribute_builder("I64ArrayAttr")
 def _i64ArrayAttr(x, context):
   return ArrayAttr.get([_i64Attr(v, context) for v in x])
 
+@register_attribute_builder("F32ArrayAttr")
+def _f32ArrayAttr(x, context):
+  return ArrayAttr.get([_f32Attr(v, context) for v in x])
+
+@register_attribute_builder("F64ArrayAttr")
+def _f64ArrayAttr(x, context):
+  return ArrayAttr.get([_f64Attr(v, context) for v in x])
 
 @register_attribute_builder("DenseI64ArrayAttr")
 def _denseI64ArrayAttr(x, context):
   return DenseI64ArrayAttr.get(x, context=context)
 
+@register_attribute_builder("SymbolNameAttr")
+def _symbolNameAttr(x, context):
+  return StringAttr.get(x, context=context)
+
+@register_attribute_builder("SymbolRefAttr")
+def _symbolRefAttr(x, context):
+  return FlatSymbolRefAttr.get(x, context=context)
 
 @register_attribute_builder("TypeAttr")
 def _typeAttr(x, context):
   return TypeAttr.get(x, context=context)
 
 
 @register_attribute_builder("TypeArrayAttr")
 def _typeArrayAttr(x, context):

mlir/test/python/dialects/python_test.py

with Context() as ctx, Location.unknown():
     # CHECK: Unit: True
     op.unit = True
     print(f"Unit: {op.unit}")
 
     # CHECK: Unit: False
     del op.unit
     print(f"Unit: {op.unit}")
 
+# CHECK-LABEL: TEST: attrBuilder
+@run
+def attrBuilder():
+  with Context() as ctx, Location.unknown():
+    ctx.allow_unregistered_dialects = True
+    op = test.AttributesOp(x_bool=True,
+                           x_i16=1,
+                           x_i32=2,
+                           x_i64=3,
+                           x_si16=-1,
+                           x_si32=-2,
+                           x_f32=1.5,
+                           x_f64=2.5,
+                           x_str='x_str',
+                           x_i32_array=[1, 2, 3],
+                           x_i64_array=[4, 5, 6],
+                           x_f32_array=[1.5, -2.5, 3.5],
+                           x_f64_array=[4.5, 5.5, -6.5],
+                           x_i64_dense=[1, 2, 3, 4, 5, 6])
+    print(op)
+
 
 # CHECK-LABEL: TEST: inferReturnTypes
 @run
 def inferReturnTypes():
   with Context() as ctx, Location.unknown(ctx):
     test.register_python_test_dialect(ctx)
     module = Module.create()
     with InsertionPoint(module.body):

mlir/test/python/python_test_ops.td

 //===----------------------------------------------------------------------===//
 
 def AttributedOp : TestOp<"attributed_op"> {
   let arguments = (ins I32Attr:$mandatory_i32,
                    OptionalAttr<I32Attr>:$optional_i32,
                    UnitAttr:$unit);
 }
 
+def AttributesOp : TestOp<"attributes_op"> {
+  let arguments = (ins BoolAttr:$x_bool,
+                   I16Attr: $x_i16,
+                   I32Attr: $x_i32,
+                   I64Attr: $x_i64,
+                   SI16Attr: $x_si16,
+                   SI32Attr: $x_si32,
+                   F32Attr: $x_f32,
+                   F64Attr: $x_f64,
+                   StrAttr: $x_str,
+                   I32ArrayAttr: $x_i32_array,
+                   I64ArrayAttr: $x_i64_array,
+                   F32ArrayAttr: $x_f32_array,
+                   F64ArrayAttr: $x_f64_array,
+                   DenseI64ArrayAttr: $x_i64_dense);
+}
+
 def PropertyOp : TestOp<"property_op"> {
   let arguments = (ins I32Attr:$property,
                    I32:$idx);
 }
 
 def DummyOp : TestOp<"dummy_op"> {
 }