[MLIR] ODS typedef gen fixes & improvements

[jdd]

Summary

• Fixes bug 48242 point 3 crash.
• Makes the improvments from points 1 & 2.

https://bugs.llvm.org/show_bug.cgi?id=48262

def RTLValueType : Type<CPred<"isRTLValueType($_self)">, "Type"> {
  string cppType = "::mlir::Type";
}

Works now, but merely by happenstance. Parameters expects a TypeParameter class def or a string representing a c++ type but doesn't enforce it.

[lattner]

Nice, thanks! Does this add a verifier style check that makes sure that inner type is an RTLValueType, or is that still the responsibility of the custom parser logic?

[jdd]

In D91939#2410304, @lattner wrote:

Nice, thanks! Does this add a verifier style check that makes sure that inner type is an RTLValueType, or is that still the responsibility of the custom parser logic?

Not sure I fully understand your question, but the generated code doesn't do _any_ type checking. It relies on the C++ types in the storage class and C++ static type checking. Your example works entirely by happenstance, which I've updated this patch's description to explain.

[lattner]

Ah right, I suppose this will matter if/when the ODS support for custom types also provides a declarative way to specify asm printing/parsing.

mlir/lib/TableGen/TypeDef.cpp

 }
 llvm::Optional<StringRef> TypeParameter::getAllocator() const {
   llvm::Init *parameterType = def->getArg(num);
   if (isa<llvm::StringInit>(parameterType))
     return llvm::Optional<StringRef>();
 
   if (auto *typeParameter = dyn_cast<llvm::DefInit>(parameterType)) {
     llvm::RecordVal *code = typeParameter->getDef()->getValue("allocator");
+    if (!code)
+      return llvm::Optional<StringRef>();
     if (llvm::CodeInit *ci = dyn_cast<llvm::CodeInit>(code->getValue()))
       return ci->getValue();
     if (isa<llvm::UnsetInit>(code->getValue()))
       return llvm::Optional<StringRef>();
 
     llvm::PrintFatalError(
         typeParameter->getDef()->getLoc(),
         "Record `" + def->getArgName(num)->getValue() +

mlir/test/mlir-tblgen/typedefs.td

 // RUN: mlir-tblgen -gen-typedef-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 
 include "mlir/IR/OpBase.td"
 
 // DECL: #ifdef GET_TYPEDEF_CLASSES
 // DECL: #undef GET_TYPEDEF_CLASSES
 
+// DECL: namespace mlir {
+// DECL: class DialectAsmParser;
+// DECL: class DialectAsmPrinter;
+// DECL: } // namespace mlir
+
 // DECL: ::mlir::Type generatedTypeParser(::mlir::MLIRContext* ctxt, ::mlir::DialectAsmParser& parser, ::llvm::StringRef mnenomic);
 // DECL: ::mlir::LogicalResult generatedTypePrinter(::mlir::Type type, ::mlir::DialectAsmPrinter& printer);
 
 // DEF: #ifdef GET_TYPEDEF_LIST
 // DEF: #undef GET_TYPEDEF_LIST
 // DEF: ::mlir::test::SimpleAType,
 // DEF: ::mlir::test::CompoundAType,
 // DEF: ::mlir::test::IndexType,

 }
 
 class TestType<string name> : TypeDef<Test_Dialect, name> { }
 
 def A_SimpleTypeA : TestType<"SimpleA"> {
 // DECL: class SimpleAType: public ::mlir::Type
 }
 
+def RTLValueType : Type<CPred<"isRTLValueType($_self)">, "Type"> {
+  string cppType = "::mlir::Type";
+}
+
 // A more complex parameterized type
 def B_CompoundTypeA : TestType<"CompoundA"> {
   let summary = "A more complex parameterized type";
   let description = "This type is to test a reasonably complex type";
   let mnemonic = "cmpnd_a";
   let parameters = (
       ins
       "int":$widthOfSomething,
       "::mlir::test::SimpleTypeA": $exampleTdType,
       "SomeCppStruct": $exampleCppType,
-      ArrayRefParameter<"int", "Matrix dimensions">:$dims
+      ArrayRefParameter<"int", "Matrix dimensions">:$dims,
+      RTLValueType:$inner
   );
 
   let genVerifyInvariantsDecl = 1;
 
 // DECL-LABEL: class CompoundAType: public ::mlir::Type
-// DECL: static ::mlir::LogicalResult verifyConstructionInvariants(Location loc, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims);
-// DECL: static ::mlir::Type getChecked(Location loc, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims);
+// DECL: static ::mlir::LogicalResult verifyConstructionInvariants(::mlir::Location loc, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
+// DECL: static ::mlir::Type getChecked(::mlir::Location loc, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // DECL: static ::llvm::StringRef getMnemonic() { return "cmpnd_a"; }
 // DECL: static ::mlir::Type parse(::mlir::MLIRContext* ctxt, ::mlir::DialectAsmParser& parser);
 // DECL: void print(::mlir::DialectAsmPrinter& printer) const;
 // DECL: int getWidthOfSomething() const;
 // DECL: ::mlir::test::SimpleTypeA getExampleTdType() const;
 // DECL: SomeCppStruct getExampleCppType() const;
 }
 

mlir/tools/mlir-tblgen/TypeDefGen.cpp

 };
 
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // GEN: TypeDef declarations
 //===----------------------------------------------------------------------===//
 
+/// Print this above all the other declarations. Contains type declarations used
+/// later on.
+static const char *const typeDefDeclHeader = R"(
+namespace mlir {
+class DialectAsmParser;
+class DialectAsmPrinter;
+} // namespace mlir
+)";
+
 /// The code block for the start of a typeDef class declaration -- singleton
 /// case.
 ///
 /// {0}: The name of the typeDef class.
 static const char *const typeDefDeclSingletonBeginStr = R"(
   class {0}: public ::mlir::Type::TypeBase<{0}, ::mlir::Type, ::mlir::TypeStorage> {{
   public:
     /// Inherit some necessary constructors from 'TypeBase'.
static const char *const typeDefParsePrint = R"(
     static ::mlir::Type parse(::mlir::MLIRContext* ctxt, ::mlir::DialectAsmParser& parser);
     void print(::mlir::DialectAsmPrinter& printer) const;
 )";
 
 /// The code block for the verifyConstructionInvariants and getChecked.
 ///
 /// {0}: List of parameters, parameters style.
 static const char *const typeDefDeclVerifyStr = R"(
-    static ::mlir::LogicalResult verifyConstructionInvariants(Location loc{0});
-    static ::mlir::Type getChecked(Location loc{0});
+    static ::mlir::LogicalResult verifyConstructionInvariants(::mlir::Location loc{0});
+    static ::mlir::Type getChecked(::mlir::Location loc{0});
 )";
 
 /// Generate the declaration for the given typeDef class.
 static void emitTypeDefDecl(const TypeDef &typeDef, raw_ostream &os) {
   SmallVector<TypeParameter, 4> params;
   typeDef.getParameters(params);
 
   // Emit the beginning string template: either the singleton or parametric

 static bool emitTypeDefDecls(const llvm::RecordKeeper &recordKeeper,
                              raw_ostream &os) {
   emitSourceFileHeader("TypeDef Declarations", os);
 
   SmallVector<TypeDef, 16> typeDefs;
   findAllTypeDefs(recordKeeper, typeDefs);
 
   IfDefScope scope("GET_TYPEDEF_CLASSES", os);
+
+  // Output the common "header".
+  os << typeDefDeclHeader;
+
   if (typeDefs.size() > 0) {
     NamespaceEmitter nsEmitter(os, typeDefs.begin()->getDialect());
 
     // Well known print/parse dispatch function declarations. These are called
     // from Dialect::parseType() and Dialect::printType() methods.
     os << "  ::mlir::Type generatedTypeParser(::mlir::MLIRContext* ctxt, "
           "::mlir::DialectAsmParser& parser, ::llvm::StringRef mnenomic);\n";
     os << "  ::mlir::LogicalResult generatedTypePrinter(::mlir::Type type, "