working

Author: makslevental

mlir/lib/TableGen/Attribute.cpp

@@ -53,7 +53,9 @@ bool Attribute::isSymbolRefAttr() const {
   return isSubClassOf("SymbolRefAttr") || isSubClassOf("FlatSymbolRefAttr");
 }
 
-bool Attribute::isEnumAttr() const { return isSubClassOf("EnumAttrInfo"); }
+bool Attribute::isEnumAttr() const {
+  return isSubClassOf("EnumAttrInfo") || isSubClassOf("EnumAttr");
+}
 
 StringRef Attribute::getStorageType() const {
   const auto *init = def->getValueInit("storageType");

mlir/python/CMakeLists.txt

@@ -606,12 +606,19 @@ if(MLIR_INCLUDE_TESTS)
     "dialects/_python_test_ops_gen.py"
     -gen-python-op-bindings
     -bind-dialect=python_test)
+  mlir_tablegen(
+    "dialects/_python_test_enums_gen.py"
+    -gen-python-enum-bindings
+    EXTRA_INCLUDES
+      "${MLIR_MAIN_SRC_DIR}/test/python")
   add_public_tablegen_target(PythonTestDialectPyIncGen)
   declare_mlir_python_sources(
     MLIRPythonTestSources.Dialects.PythonTest.ops_gen
     ROOT_DIR "${CMAKE_CURRENT_BINARY_DIR}"
     ADD_TO_PARENT MLIRPythonTestSources.Dialects.PythonTest
-    SOURCES "dialects/_python_test_ops_gen.py")
+    SOURCES
+      "dialects/_python_test_ops_gen.py"
+      "dialects/_python_test_enums_gen.py")
 
   declare_mlir_python_extension(MLIRPythonTestSources.PythonTestExtension
     MODULE_NAME _mlirPythonTest

mlir/python/mlir/dialects/python_test.py

@@ -3,6 +3,7 @@
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 from ._python_test_ops_gen import *
+from ._python_test_enums_gen import *
 from .._mlir_libs._mlirPythonTest import (
     TestAttr,
     TestType,

mlir/test/python/CMakeLists.txt

@@ -3,6 +3,8 @@ mlir_tablegen(lib/PythonTestDialect.h.inc -gen-dialect-decls)
 mlir_tablegen(lib/PythonTestDialect.cpp.inc -gen-dialect-defs)
 mlir_tablegen(lib/PythonTestOps.h.inc -gen-op-decls)
 mlir_tablegen(lib/PythonTestOps.cpp.inc -gen-op-defs)
+mlir_tablegen(lib/PythonTestEnums.h.inc -gen-enum-decls)
+mlir_tablegen(lib/PythonTestEnums.cpp.inc -gen-enum-defs)
 mlir_tablegen(lib/PythonTestAttributes.h.inc -gen-attrdef-decls)
 mlir_tablegen(lib/PythonTestAttributes.cpp.inc -gen-attrdef-defs)
 mlir_tablegen(lib/PythonTestTypes.h.inc -gen-typedef-decls)

mlir/test/python/dialects/python_test.py

@@ -5,6 +5,13 @@
 import mlir.dialects.python_test as test
 import mlir.dialects.tensor as tensor
 import mlir.dialects.arith as arith
+from mlir.dialects import llvm
+from mlir.dialects._llvm_enum_gen import (
+    _llvm_integeroverflowflagsattr as llvm_integeroverflowflagsattr,
+)
+from mlir.dialects._python_test_enums_gen import (
+    _llvm_integeroverflowflagsattr as python_test_integeroverflowflagsattr,
+)
 
 test.register_python_test_dialect(get_dialect_registry())
 
@@ -543,3 +550,13 @@ def testInferTypeOpInterface():
             two_operands = test.InferResultsVariadicInputsOp(single=zero, doubled=zero)
             # CHECK: f32
             print(two_operands.result.type)
+
+
+# CHECK-LABEL: TEST: testEnumNamespacing
+@run
+def testEnumNamespacing():
+    with Context() as ctx, Location.unknown(ctx):
+        # CHECK: #llvm.overflow<none>
+        print(llvm_integeroverflowflagsattr(llvm.IntegerOverflowFlags.none, ctx))
+        # CHECK: #python_test.overflow<none>
+        print(python_test_integeroverflowflagsattr(test.IntegerOverflowFlags.none, ctx))

mlir/test/python/lib/PythonTestDialect.cpp

@@ -9,10 +9,12 @@
 #include "PythonTestDialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/OpImplementation.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 #include "PythonTestDialect.cpp.inc"
 
+#include "PythonTestEnums.cpp.inc"
 #define GET_ATTRDEF_CLASSES
 #include "PythonTestAttributes.cpp.inc"
 

mlir/test/python/lib/PythonTestDialect.h

@@ -19,6 +19,7 @@
 #define GET_OP_CLASSES
 #include "PythonTestOps.h.inc"
 
+#include "PythonTestEnums.h.inc"
 #define GET_ATTRDEF_CLASSES
 #include "PythonTestAttributes.h.inc"
 

mlir/test/python/lit.local.cfg

@@ -2,3 +2,4 @@ config.environment["ASAN_OPTIONS"] = "detect_leaks=0"
 if not config.enable_bindings_python:
     config.unsupported = True
 config.excludes.add("python_test_ops.td")
+config.excludes.add("python_test_enums.td")

mlir/test/python/python_test_ops.td

@@ -10,6 +10,7 @@
 #define PYTHON_TEST_OPS
 
 include "mlir/IR/AttrTypeBase.td"
+include "mlir/IR/EnumAttr.td"
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
@@ -48,6 +49,24 @@ def TestType : TestType<"TestType", "test_type">;
 
 def TestAttr : TestAttr<"TestAttr", "test_attr">;
 
+def IOFnone : I32BitEnumAttrCaseNone<"none">;
+def IOFnsw  : I32BitEnumAttrCaseBit<"nsw", 0>;
+def IOFnuw  : I32BitEnumAttrCaseBit<"nuw", 1>;
+
+def IntegerOverflowFlags : I32BitEnumAttr<
+    "IntegerOverflowFlags", "",
+    [IOFnone, IOFnsw, IOFnuw]> {
+  let separator = ", ";
+  let cppNamespace = "python_test";
+  let genSpecializedAttr = 0;
+}
+
+// This is intentionally prefixed with LLVM to test for collision in AttrBuilder.
+def LLVM_IntegerOverflowFlagsAttr :
+    EnumAttr<Python_Test_Dialect, IntegerOverflowFlags, "overflow"> {
+  let assemblyFormat = "`<` $value `>`";
+}
+
 //===----------------------------------------------------------------------===//
 // Operation definitions.
 //===----------------------------------------------------------------------===//

mlir/tools/mlir-tblgen/EnumPythonBindingGen.cpp

@@ -97,18 +97,16 @@ static bool extractUIntBitwidth(StringRef uintType, int64_t &bitwidth) {
 /// Emits an attribute builder for the given enum attribute to support automatic
 /// conversion between enum values and attributes in Python. Returns
 /// `false` on success, `true` on failure.
-static bool emitAttributeBuilder(const EnumAttr &enumAttr, raw_ostream &os) {
+static bool emitAttributeBuilderRegistration(const EnumAttr &enumAttr,
+                                             raw_ostream &os) {
   int64_t bitwidth;
   if (extractUIntBitwidth(enumAttr.getUnderlyingType(), bitwidth)) {
     llvm::errs() << "failed to identify bitwidth of "
                  << enumAttr.getUnderlyingType();
     return true;
   }
 
-  llvm::SmallVector<StringRef> namespaces;
-  enumAttr.getStorageType().ltrim("::").split(namespaces, "::");
-  namespaces = llvm::SmallVector<StringRef>{llvm::drop_end(namespaces)};
-  std::string namespace_ = getAttributeNameSpace(namespaces);
+  std::string namespace_ = getEnumAttributeNameSpace(enumAttr);
   if (!namespace_.empty())
     namespace_ += "_";
 
@@ -127,8 +125,9 @@ static bool emitAttributeBuilder(const EnumAttr &enumAttr, raw_ostream &os) {
 /// Emits an attribute builder for the given dialect enum attribute to support
 /// automatic conversion between enum values and attributes in Python. Returns
 /// `false` on success, `true` on failure.
-static bool emitDialectEnumAttributeBuilder(const AttrOrTypeDef &attr,
-                                            raw_ostream &os) {
+static bool emitDialectEnumAttributeBuilderRegistration(const llvm::Record &def,
+                                                        raw_ostream &os) {
+  const AttrOrTypeDef attr(&def);
   StringRef mnemonic = attr.getMnemonic().value();
   std::optional<StringRef> assemblyFormat = attr.getAssemblyFormat();
   StringRef dialect = attr.getDialect().getName();
@@ -145,15 +144,15 @@ static bool emitDialectEnumAttributeBuilder(const AttrOrTypeDef &attr,
     return true;
   }
 
-  llvm::SmallVector<StringRef> namespaces;
-  attr.getStorageNamespace().ltrim("::").split(namespaces, "::");
-  std::string namespace_ = getAttributeNameSpace(namespaces);
+  EnumAttr enumAttr(def);
+  std::string namespace_ = getEnumAttributeNameSpace(enumAttr);
   if (!namespace_.empty())
     namespace_ += "_";
 
   os << llvm::formatv("@register_attribute_builder(\"{0}{1}\")\n", namespace_,
-                      attr.getName());
-  os << llvm::formatv("def _{0}(x, context):\n", attr.getName().lower());
+                      enumAttr.getAttrDefName());
+  os << llvm::formatv("def _{0}(x, context):\n",
+                      enumAttr.getAttrDefName().lower());
   os << llvm::formatv("    return "
                       "_ods_ir.Attribute.parse(f'{0}', context=context)\n\n",
                       formatString);
@@ -164,17 +163,32 @@ static bool emitDialectEnumAttributeBuilder(const AttrOrTypeDef &attr,
 /// `false` on success, `true` on failure.
 static bool emitPythonEnums(const llvm::RecordKeeper &recordKeeper,
                             raw_ostream &os) {
+  llvm::SmallDenseSet<StringRef> alreadyEmitted;
   os << fileHeader;
+  for (const auto &it :
+       recordKeeper.getAllDerivedDefinitionsIfDefined("EnumAttr")) {
+    EnumAttr *enumAttr;
+    for (const auto &value : it->getValues())
+      if (value.getType()->getAsString() == "EnumAttrInfo")
+        enumAttr = new EnumAttr(value.getValue()->getRecordKeeper().getDef(
+            value.getValue()->getAsString()));
+    if (enumAttr) {
+      emitEnumClass(*enumAttr, os);
+      alreadyEmitted.insert(enumAttr->getEnumClassName());
+    }
+  }
   for (auto &it :
        recordKeeper.getAllDerivedDefinitionsIfDefined("EnumAttrInfo")) {
     EnumAttr enumAttr(*it);
-    emitEnumClass(enumAttr, os);
-    emitAttributeBuilder(enumAttr, os);
+    if (!alreadyEmitted.contains(enumAttr.getEnumClassName()))
+      emitEnumClass(enumAttr, os);
+    if (emitAttributeBuilderRegistration(enumAttr, os))
+      return true;
   }
   for (const auto &it :
        recordKeeper.getAllDerivedDefinitionsIfDefined("EnumAttr")) {
-    const AttrOrTypeDef attr(&*it);
-    return emitDialectEnumAttributeBuilder(attr, os);
+    if (emitDialectEnumAttributeBuilderRegistration(*it, os))
+      return true;
   }
 
   return false;

mlir/tools/mlir-tblgen/OpGenHelpers.cpp

@@ -81,8 +81,16 @@ bool mlir::tblgen::isPythonReserved(StringRef str) {
   return reserved.contains(str);
 }
 
-std::string
-mlir::tblgen::getAttributeNameSpace(llvm::SmallVector<StringRef> namespaces) {
+std::string mlir::tblgen::getEnumAttributeNameSpace(const EnumAttr &enumAttr) {
+  llvm::SmallVector<StringRef> namespaces;
+  if (enumAttr.getCppNamespace().empty() &&
+      enumAttr.getBaseAttr().isEnumAttr()) {
+    EnumAttr(enumAttr.getBaseAttr().getDef())
+        .getCppNamespace()
+        .ltrim("::")
+        .split(namespaces, "::");
+  } else
+    enumAttr.getCppNamespace().ltrim("::").split(namespaces, "::");
   std::string namespace_;
   if (namespaces[0] == "mlir")
     namespace_ = llvm::join(llvm::drop_begin(namespaces), "_");

mlir/tools/mlir-tblgen/OpGenHelpers.h

@@ -13,6 +13,7 @@
 #ifndef MLIR_TOOLS_MLIRTBLGEN_OPGENHELPERS_H_
 #define MLIR_TOOLS_MLIRTBLGEN_OPGENHELPERS_H_
 
+#include "mlir/TableGen/Attribute.h"
 #include "llvm/TableGen/Record.h"
 #include <vector>
 
@@ -28,8 +29,7 @@ getRequestedOpDefinitions(const llvm::RecordKeeper &recordKeeper);
 /// Regenerate using python -c"print(set(sorted(__import__('keyword').kwlist)))"
 bool isPythonReserved(llvm::StringRef str);
 
-std::string
-getAttributeNameSpace(llvm::SmallVector<llvm::StringRef> namespaces);
+std::string getEnumAttributeNameSpace(const EnumAttr &enumAttr);
 
 } // namespace tblgen
 } // namespace mlir

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

@@ -530,30 +530,30 @@ constexpr const char *multiResultAppendTemplate = "results.extend({0})";
 ///   {0} is the builder argument name;
 ///   {1} is the attribute builder from raw;
 ///   {2} is the attribute builder from raw;
-///   {3} is the attribute's dialect.
+///   {3} is the attribute's fully qualified namespace.
 /// Use the value the user passed in if either it is already an Attribute or
 /// there is no method registered to make it an Attribute.
 constexpr const char *initAttributeWithBuilderTemplate =
     R"Py(attributes["{1}"] = ({0} if (
     issubclass(type({0}), _ods_ir.Attribute) or
     not (_ods_ir.AttrBuilder.contains('{3}') or _ods_ir.AttrBuilder.contains('{2}{3}'))) else
       (_ods_ir.AttrBuilder.get('{3}')({0}, context=_ods_context) if _ods_ir.AttrBuilder.contains('{3}')
-       else _ods_ir.AttrBuilder.contains('{2}{3}')({0}, context=_ods_context))))Py";
+       else _ods_ir.AttrBuilder.get('{2}{3}')({0}, context=_ods_context))))Py";
 
 /// Template for attribute builder from raw input for optional attribute in the
 /// operation builder.
 ///   {0} is the builder argument name;
 ///   {1} is the attribute builder from raw;
 ///   {2} is the attribute builder from raw;
-///   {3} is the attribute's dialect.
+///   {3} is the attribute's fully qualified namespace.
 /// Use the value the user passed in if either it is already an Attribute or
 /// there is no method registered to make it an Attribute.
 constexpr const char *initOptionalAttributeWithBuilderTemplate =
     R"Py(if {0} is not None: attributes["{1}"] = ({0} if (
         issubclass(type({0}), _ods_ir.Attribute) or
         not (_ods_ir.AttrBuilder.contains('{3}') or _ods_ir.AttrBuilder.contains('{2}{3}'))) else
           (_ods_ir.AttrBuilder.get('{3}')({0}, context=_ods_context) if _ods_ir.AttrBuilder.contains('{3}')
-           else _ods_ir.AttrBuilder.contains('{2}{3}')({0}, context=_ods_context))))Py";
+           else _ods_ir.AttrBuilder.get('{2}{3}')({0}, context=_ods_context))))Py";
 
 constexpr const char *initUnitAttributeTemplate =
     R"Py(if bool({1}): attributes["{0}"] = _ods_ir.UnitAttr.get(
@@ -681,10 +681,8 @@ populateBuilderLinesAttr(const Operator &op,
       continue;
     }
 
-    llvm::SmallVector<StringRef> namespaces;
-    attribute->attr.getStorageType().ltrim("::").split(namespaces, "::");
-    namespaces = llvm::SmallVector<StringRef>{llvm::drop_end(namespaces)};
-    std::string namespace_ = getAttributeNameSpace(namespaces);
+    EnumAttr enumAttr(attribute->attr.getDef());
+    std::string namespace_ = getEnumAttributeNameSpace(enumAttr);
     if (!namespace_.empty())
       namespace_ += "_";