92233062c1
This PR implements python enum bindings for *all* the enums - this includes `I*Attrs` (including positional/bit) and `Dialect/EnumAttr`.
There are a few parts to this:
1. CMake: a small addition to `declare_mlir_dialect_python_bindings` and `declare_mlir_dialect_extension_python_bindings` to generate the enum, a boolean arg `GEN_ENUM_BINDINGS` to make it opt-in (even though it works for basically all of the dialects), and an optional `GEN_ENUM_BINDINGS_TD_FILE` for handling corner cases.
2. EnumPythonBindingGen.cpp: there are two weedy aspects here that took investigation:
1. If an enum attribute is not a `Dialect/EnumAttr` then the `EnumAttrInfo` record is canonical, as far as both the cases of the enum **and the `AttrDefName`**. On the otherhand, if an enum is a `Dialect/EnumAttr` then the `EnumAttr` record has the correct `AttrDefName` ("load bearing", i.e., populates `ods.ir.AttributeBuilder('<NAME>')`) but its `enum` field contains the cases, which is an instance of `EnumAttrInfo`. The solution is to generate an one enum class for both `Dialect/EnumAttr` and "independent" `EnumAttrInfo` but to make that class interopable with two builder registrations that both do the right thing (see next sub-bullet).
2. Because we don't have a good connection to cpp `EnumAttr`, i.e., only the `enum class` getters are exposed (like `DimensionAttr::get(Dimension value)`), we have to resort to parsing e.g., `Attribute.parse(f'#gpu<dim {x}>')`. This means that the set of supported `assemblyFormat`s (for the enum) is fixed at compile of MLIR (currently 2, the only 2 I saw). There might be some things that could be done here but they would require quite a bit more C API work to support generically (e.g., casting ints to enum cases and binding all the getters or going generically through the `symbolize*` methods, like `symbolizeDimension(uint32_t)` or `symbolizeDimension(StringRef)`).
A few small changes:
1. In addition, since this patch registers default builders for attributes where people might've had their own builders already written, I added a `replace` param to `AttributeBuilder.insert` (`False` by default).
2. `makePythonEnumCaseName` can't handle all the different ways in which people write their enum cases, e.g., `llvm.CConv.Intel_OCL_BI`, which gets turned into `INTEL_O_C_L_B_I` (because `llvm::convertToSnakeFromCamelCase` doesn't look for runs of caps). So I dropped it. On the otherhand regularization does need to done because some enums have `None` as a case (and others might have other python keywords).
3. I turned on `llvm` dialect generation here in order to test `nvvm.WGMMAScaleIn`, which is an enum with [[ d7e26b5620/mlir/include/mlir/IR/EnumAttr.td (L22-L25) | no explicit discriminator ]] for the `neg` case.
Note, dialects that didn't get a `GEN_ENUM_BINDINGS` don't have any enums to generate.
Let me know if I should add more tests (the three trivial ones I added exercise both the supported `assemblyFormat`s and `replace=True`).
Reviewed By: stellaraccident
Differential Revision: https://reviews.llvm.org/D157934
110 lines
3.9 KiB
TableGen
110 lines
3.9 KiB
TableGen
// RUN: mlir-tblgen -gen-python-enum-bindings %s -I %S/../../include | FileCheck %s
|
|
|
|
include "mlir/IR/EnumAttr.td"
|
|
|
|
def Test_Dialect : Dialect {
|
|
let name = "TestDialect";
|
|
let cppNamespace = "::test";
|
|
}
|
|
|
|
// CHECK: Autogenerated by mlir-tblgen; don't manually edit.
|
|
|
|
// CHECK: from enum import IntEnum, auto, IntFlag
|
|
// CHECK: from ._ods_common import _cext as _ods_cext
|
|
// CHECK: from ..ir import register_attribute_builder
|
|
// CHECK: _ods_ir = _ods_cext.ir
|
|
|
|
def One : I32EnumAttrCase<"CaseOne", 1, "one">;
|
|
def Two : I32EnumAttrCase<"CaseTwo", 2, "two">;
|
|
def NegOne : I32EnumAttrCase<"CaseNegOne", -1, "negone">;
|
|
|
|
def MyEnum : I32EnumAttr<"MyEnum", "An example 32-bit enum", [One, Two, NegOne]>;
|
|
// CHECK-LABEL: class MyEnum(IntEnum):
|
|
// CHECK: """An example 32-bit enum"""
|
|
|
|
// CHECK: CaseOne = 1
|
|
// CHECK: CaseTwo = 2
|
|
// CHECK: CaseNegOne = auto()
|
|
|
|
// CHECK: def __str__(self):
|
|
// CHECK: if self is MyEnum.CaseOne:
|
|
// CHECK: return "one"
|
|
// CHECK: if self is MyEnum.CaseTwo:
|
|
// CHECK: return "two"
|
|
// CHECK: if self is MyEnum.CaseNegOne:
|
|
// CHECK: return "negone"
|
|
// CHECK: raise ValueError("Unknown MyEnum enum entry.")
|
|
|
|
// CHECK: @register_attribute_builder("MyEnum")
|
|
// CHECK: def _myenum(x, context):
|
|
// CHECK: return _ods_ir.IntegerAttr.get(_ods_ir.IntegerType.get_signless(32, context=context), int(x))
|
|
|
|
def TestMyEnum_Attr : EnumAttr<Test_Dialect, MyEnum, "enum">;
|
|
|
|
def One64 : I64EnumAttrCase<"CaseOne64", 1, "one">;
|
|
def Two64 : I64EnumAttrCase<"CaseTwo64", 2, "two">;
|
|
|
|
def MyEnum64 : I64EnumAttr<"MyEnum64", "An example 64-bit enum", [One64, Two64]>;
|
|
// CHECK-LABEL: class MyEnum64(IntEnum):
|
|
// CHECK: """An example 64-bit enum"""
|
|
|
|
// CHECK: CaseOne64 = 1
|
|
// CHECK: CaseTwo64 = 2
|
|
|
|
// CHECK: def __str__(self):
|
|
// CHECK: if self is MyEnum64.CaseOne64:
|
|
// CHECK: return "one"
|
|
// CHECK: if self is MyEnum64.CaseTwo64:
|
|
// CHECK: return "two"
|
|
// CHECK: raise ValueError("Unknown MyEnum64 enum entry.")
|
|
|
|
// CHECK: @register_attribute_builder("MyEnum64")
|
|
// CHECK: def _myenum64(x, context):
|
|
// CHECK: return _ods_ir.IntegerAttr.get(_ods_ir.IntegerType.get_signless(64, context=context), int(x))
|
|
|
|
def TestBitEnum
|
|
: I32BitEnumAttr<"TestBitEnum", "", [
|
|
I32BitEnumAttrCaseBit<"User", 0, "user">,
|
|
I32BitEnumAttrCaseBit<"Group", 1, "group">,
|
|
I32BitEnumAttrCaseBit<"Other", 2, "other">,
|
|
]> {
|
|
let genSpecializedAttr = 0;
|
|
let separator = " | ";
|
|
}
|
|
|
|
def TestBitEnum_Attr : EnumAttr<Test_Dialect, TestBitEnum, "testbitenum">;
|
|
|
|
// CHECK-LABEL: class TestBitEnum(IntFlag):
|
|
|
|
// CHECK: User = 1
|
|
// CHECK: Group = 2
|
|
// CHECK: Other = 4
|
|
|
|
// CHECK: def __iter__(self):
|
|
// CHECK: return iter([case for case in type(self) if (self & case) is case])
|
|
// CHECK: def __len__(self):
|
|
// CHECK: return bin(self).count("1")
|
|
|
|
// CHECK: def __str__(self):
|
|
// CHECK: if len(self) > 1:
|
|
// CHECK: return " | ".join(map(str, self))
|
|
// CHECK: if self is TestBitEnum.User:
|
|
// CHECK: return "user"
|
|
// CHECK: if self is TestBitEnum.Group:
|
|
// CHECK: return "group"
|
|
// CHECK: if self is TestBitEnum.Other:
|
|
// CHECK: return "other"
|
|
// CHECK: raise ValueError("Unknown TestBitEnum enum entry.")
|
|
|
|
// CHECK: @register_attribute_builder("TestBitEnum")
|
|
// CHECK: def _testbitenum(x, context):
|
|
// CHECK: return _ods_ir.IntegerAttr.get(_ods_ir.IntegerType.get_signless(32, context=context), int(x))
|
|
|
|
// CHECK: @register_attribute_builder("TestBitEnum_Attr")
|
|
// CHECK: def _testbitenum_attr(x, context):
|
|
// CHECK: return _ods_ir.Attribute.parse(f'#TestDialect<testbitenum {str(x)}>', context=context)
|
|
|
|
// CHECK: @register_attribute_builder("TestMyEnum_Attr")
|
|
// CHECK: def _testmyenum_attr(x, context):
|
|
// CHECK: return _ods_ir.Attribute.parse(f'#TestDialect<enum {str(x)}>', context=context)
|