[PDLL] Add support for tablegen includes and importing ODS information

[rriddle]

Summary

This commit adds support for processing tablegen include files, and importing
various information from ODS. This includes operations, attribute+type constraints,
attribute/operation/type interfaces, etc. This will allow for much more robust tooling,
and also allows for referencing ODS constructs directly within PDLL (imported interfaces
can be used as constraints, operation result names can be used for member access, etc).

[jpienaar]

Just half a scan (sorry have to context switch again but asking some in interim)

llvm/include/llvm/Support/SourceMgr.h

103

Could we split these out?

mlir/include/mlir/Tools/PDLL/ODS/Constraint.h

42

Are these std::string due to life time concerns?

mlir/include/mlir/Tools/PDLL/ODS/Context.h

65

Contrary to MLIR IR side is there any expectation that this is useful beyond debugging?

mlir/include/mlir/Tools/PDLL/ODS/Operation.h

115

What does opaque here signify?

[jpienaar]

mlir/include/mlir/Tools/PDLL/ODS/Constraint.h

1

PDLL instead of PD:L

7

(PDLL ODS constraints is such a mouthful that it may make sense to add file header comment)

mlir/include/mlir/Tools/PDLL/ODS/Context.h

42

What happens if a constraint by that name already exists?

48

The above have add being const reference return, while here add is for mutable and lookup for non-mutable without insertion. What mutation is expected here/why isn't that expected above?

57

insertOperation? (This is why your comment even says :-)). Up to you.

mlir/include/mlir/Tools/PDLL/ODS/Dialect.h

36

Ditto

43

Out dated comment? (The name makes more sense to me with this comment)

mlir/include/mlir/Tools/PDLL/ODS/Operation.h

55

Same question wrt string vs stringref here.

71

"represents a ... representation" feels off

124

And here adds don't return anything (these feel inconsistent to have same names/prefixes enable different things)

mlir/lib/Tools/PDLL/ODS/Context.cpp

102

Could we use the scoped & indented ostream emitter? (Seems would make it more less likely to forget a space)

mlir/lib/Tools/PDLL/Parser/Parser.cpp

716

Sneaky :-) And include paths are not an issue?

[nicolasvasilache]

@rriddle could you land your stack?

Also, what do you expect the support to look like for something like class RankedFloatElementsAttr<int width, list<int> dims> : ?
Is the idea that pdll will understand int as a first class citizen or that we'll go through e.g. I64?
What about list<int> ?

Thanks!

[rriddle]

In D119900#3356279, @nicolasvasilache wrote:

@rriddle could you land your stack?

Yep, sorry for the delay. Now that Jacques reviewed, PDL(L) is back at the top of my stack, so I'll be going through things tomorrow (PST).

Also, what do you expect the support to look like for something like class RankedFloatElementsAttr<int width, list<int> dims> : ?
Is the idea that pdll will understand int as a first class citizen or that we'll go through e.g. I64?
What about list<int> ?

For tablegen import, we can only really import defs at this point; i.e., we won't be able to import templated classes. So for now, if we want to
use them we'll generally need to explicitly define the templates we care about in .td and then import the fully specialized def.

[rriddle]

mlir/include/mlir/Tools/PDLL/ODS/Constraint.h

42

Yeah, in a follow up I intend to make the summary/description stuff all optional.

mlir/include/mlir/Tools/PDLL/ODS/Context.h

42

Just returns the previous one. Added in asserts that the info is the same on duplicate insertion.

48

Constraints are self-contained, and don't really need any mutation after insertion. Dialects can have additional constructs inserted (operations/etc). We could make the constraints non-const on return, but there isn't a reason to right now.

65

Not really. Printing here is really only for debugging/testing.

mlir/include/mlir/Tools/PDLL/ODS/Operation.h

55

Yep, this is for lifetime issues.

115

Just dropped all of the opaque.

124

Keeping these as add now that the functions returning things are called "insert".

llvm/include/llvm/Support/SourceMgr.h

 public:
   SourceMgr() = default;
   SourceMgr(const SourceMgr &) = delete;
   SourceMgr &operator=(const SourceMgr &) = delete;
   SourceMgr(SourceMgr &&) = default;
   SourceMgr &operator=(SourceMgr &&) = default;
   ~SourceMgr() = default;
 
+  /// Return the include directories of this source manager.
+  ArrayRef<std::string> getIncludeDirs() const { return IncludeDirectories; }
+
   void setIncludeDirs(const std::vector<std::string> &Dirs) {
     IncludeDirectories = Dirs;
   }
 
   /// Specify a diagnostic handler to be invoked every time PrintMessage is
   /// called. \p Ctx is passed into the handler when it is invoked.
   void setDiagHandler(DiagHandlerTy DH, void *Ctx = nullptr) {
     DiagHandler = DH;
unsigned AddNewSourceBuffer(std::unique_ptr<MemoryBuffer> F,
                               SMLoc IncludeLoc) {
     SrcBuffer NB;
     NB.Buffer = std::move(F);
     NB.IncludeLoc = IncludeLoc;
     Buffers.push_back(std::move(NB));
     return Buffers.size();
   }
 
+  /// Takes the source buffers from the given source manager and append them to
+  /// the current manager.
+  void takeSourceBuffersFrom(SourceMgr &SrcMgr) {
+    std::move(SrcMgr.Buffers.begin(), SrcMgr.Buffers.end(),
+              std::back_inserter(Buffers));
+    SrcMgr.Buffers.clear();
+  }
+
   /// Search for a file with the specified name in the current directory or in
   /// one of the IncludeDirs.
   ///
   /// If no file is found, this returns 0, otherwise it returns the buffer ID
   /// of the stacked file. The full path to the included file can be found in
   /// \p IncludedFile.
   unsigned AddIncludeFile(const std::string &Filename, SMLoc IncludeLoc,
                           std::string &IncludedFile);

mlir/include/mlir/IR/OpBase.td

 class DialectType<Dialect d, Pred condition, string descr = "",
                   string cppClassName = "::mlir::Type"> :
     Type<condition, descr, cppClassName> {
   Dialect dialect = d;
 }
 
 // A variadic type constraint. It expands to zero or more of the base type. This
 // class is used for supporting variadic operands/results.
-class Variadic<Type type> : TypeConstraint<type.predicate, type.summary> {
+class Variadic<Type type> : TypeConstraint<type.predicate, type.summary,
+                                           type.cppClassName> {
   Type baseType = type;
 }
 
 // A nested variadic type constraint. It expands to zero or more variadic ranges
 // of the base type. This class is used for supporting variadic operands and
 // results. `variadicSegmentAttrName` should correspond to the name of an
 // I32ElementsAttr argument that provides the sizes of the inner variadic
 // operand groups.
 class VariadicOfVariadic<Type type, string variadicSegmentAttrName>
     : Variadic<type> {
   string segmentAttrName = variadicSegmentAttrName;
 }
 
 // An optional type constraint. It expands to either zero or one of the base
 // type. This class is used for supporting optional operands/results.
-class Optional<Type type> : TypeConstraint<type.predicate, type.summary> {
+class Optional<Type type> : TypeConstraint<type.predicate, type.summary,
+                                           type.cppClassName> {
   Type baseType = type;
 }
 
 // A type that can be constructed using MLIR::Builder.
 // Note that this does not "inherit" from Type because it would require
 // duplicating Type subclasses for buildable and non-buildable cases to avoid
 // diamond "inheritance".
 // TODO: we may extend this to a more general 'Buildable' trait, making some

mlir/include/mlir/TableGen/Constraint.h

public:
   // must be substituted with an expression returning an mlir::Type or
   // mlir::Attribute.
   std::string getConditionTemplate() const;
 
   // Returns the user-readable description of this constraint. If the
   // description is not provided, returns the TableGen def name.
   StringRef getSummary() const;
 
+  /// Returns the name of the TablGen def of this constraint. In some cases
+  /// where the current def is anonymous, the name of the base def is used (e.g.
+  /// `Optional<>`/`Variadic<>` type constraints).
+  StringRef getDefName() const;
+
   Kind getKind() const { return kind; }
 
 protected:
   // The TableGen definition of this constraint.
   const llvm::Record *def;
 
 private:
   // What kind of constraint this is.

mlir/include/mlir/Tools/PDLL/AST/Context.h

 //===- Context.h - PDLL AST Context -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TOOLS_PDLL_AST_CONTEXT_H_
 #define MLIR_TOOLS_PDLL_AST_CONTEXT_H_
 
 #include "mlir/Support/StorageUniquer.h"
 #include "mlir/Tools/PDLL/AST/Diagnostic.h"
 
 namespace mlir {
 namespace pdll {
+namespace ods {
+class Context;
+} // namespace ods
+
 namespace ast {
 /// This class represents the main context of the PDLL AST. It handles
 /// allocating all of the AST constructs, and manages all state necessary for
 /// the AST.
 class Context {
 public:
-  Context();
+  explicit Context(ods::Context &odsContext);
   Context(const Context &) = delete;
   Context &operator=(const Context &) = delete;
 
   /// Return the allocator owned by this context.
   llvm::BumpPtrAllocator &getAllocator() { return allocator; }
 
   /// Return the storage uniquer used for AST types.
   StorageUniquer &getTypeUniquer() { return typeUniquer; }
 
+  /// Return the ODS context used by the AST.
+  ods::Context &getODSContext() { return odsContext; }
+  const ods::Context &getODSContext() const { return odsContext; }
+
   /// Return the diagnostic engine of this context.
   DiagnosticEngine &getDiagEngine() { return diagEngine; }
 
 private:
   /// The diagnostic engine of this AST context.
   DiagnosticEngine diagEngine;
 
+  /// The ODS context used by the AST.
+  ods::Context &odsContext;
+
   /// The allocator used for AST nodes, and other entities allocated within the
   /// context.
   llvm::BumpPtrAllocator allocator;
 
   /// The uniquer used for creating AST types.
   StorageUniquer typeUniquer;
 };
 
 } // namespace ast
 } // namespace pdll
 } // namespace mlir
 
 #endif // MLIR_TOOLS_PDLL_AST_CONTEXT_H_

mlir/include/mlir/Tools/PDLL/ODS/Constraint.h

+//===- Constraint.h - MLIR PD:L ODS Constraints -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TOOLS_PDLL_ODS_CONSTRAINT_H_
+#define MLIR_TOOLS_PDLL_ODS_CONSTRAINT_H_
+
+#include <string>
+
+#include "mlir/Support/LLVM.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+
+namespace mlir {
+namespace pdll {
+namespace ods {
+
+//===----------------------------------------------------------------------===//
+// Constraint
+//===----------------------------------------------------------------------===//
+
+/// This class represents a generic ODS constraint.
+class Constraint {
+public:
+  /// Return the name of this constraint.
+  StringRef getName() const { return name; }
+
+  /// Return the summary of this constraint.
+  StringRef getSummary() const { return summary; }
+
+protected:
+  Constraint(StringRef name, StringRef summary)
+      : name(name.str()), summary(summary.str()) {}
+  Constraint(const Constraint &) = delete;
+
+private:
+  /// The name of the constraint.
+  std::string name;
+  /// A summary of the constraint.
+  std::string summary;
+};
+
+//===----------------------------------------------------------------------===//
+// AttributeConstraint
+//===----------------------------------------------------------------------===//
+
+/// This class represents a generic ODS Attribute constraint.
+class AttributeConstraint : public Constraint {
+public:
+  /// Return the name of the underlying c++ class of this constraint.
+  StringRef getCppClass() const { return cppClassName; }
+
+private:
+  AttributeConstraint(StringRef name, StringRef summary, StringRef cppClassName)
+      : Constraint(name, summary), cppClassName(cppClassName.str()) {}
+
+  /// The c++ class of the constraint.
+  std::string cppClassName;
+
+  /// Allow access to the constructor.
+  friend class Context;
+};
+
+//===----------------------------------------------------------------------===//
+// TypeConstraint
+//===----------------------------------------------------------------------===//
+
+/// This class represents a generic ODS Type constraint.
+class TypeConstraint : public Constraint {
+public:
+  /// Return the name of the underlying c++ class of this constraint.
+  StringRef getCppClass() const { return cppClassName; }
+
+private:
+  TypeConstraint(StringRef name, StringRef summary, StringRef cppClassName)
+      : Constraint(name, summary), cppClassName(cppClassName.str()) {}
+
+  /// The c++ class of the constraint.
+  std::string cppClassName;
+
+  /// Allow access to the constructor.
+  friend class Context;
+};
+
+} // namespace ods
+} // namespace pdll
+} // namespace mlir
+
+#endif // MLIR_TOOLS_PDLL_ODS_CONSTRAINT_H_

mlir/include/mlir/Tools/PDLL/ODS/Context.h

+//===- Context.h - MLIR PDLL ODS Context ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TOOLS_PDLL_ODS_CONTEXT_H_
+#define MLIR_TOOLS_PDLL_ODS_CONTEXT_H_
+
+#include <string>
+
+#include "mlir/Support/LLVM.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+
+namespace llvm {
+class SMLoc;
+} // namespace llvm
+
+namespace mlir {
+namespace pdll {
+namespace ods {
+class AttributeConstraint;
+class Dialect;
+class Operation;
+class TypeConstraint;
+
+/// This class contains all of the registered ODS operation classes.
+class Context {
+public:
+  Context();
+  ~Context();
+
+  /// Register a new attribute constraint with the context. Returns the inserted
+  /// constraint.
+  const AttributeConstraint &
+  addAttributeConstraint(StringRef name, StringRef summary, StringRef cppClass);
+
+  /// Register a new type constraint with the context. Returns the inserted
+  /// constraint.
+  const TypeConstraint &addTypeConstraint(StringRef name, StringRef summary,
+                                          StringRef cppClass);
+
+  /// Register a new dialect with the context. Returns the inserted dialect.
+  Dialect &addDialect(StringRef name);
+
+  /// Lookup a dialect registered with the given name, or null if no dialect
+  /// with that name is registered.
+  const Dialect *lookupDialect(StringRef name) const;
+
+  /// Register a new operation with the context. Returns the inserted operation,
+  /// and a boolean indicating if the operation newly inserted (false if the
+  /// operation already existed).
+  std::pair<Operation *, bool> addOperation(StringRef name, StringRef summary,
+                                            StringRef desc, SMLoc loc);
+
+  /// Lookup an operation registered with the given name, or null if no
+  /// operation with that name is registered.
+  const Operation *lookupOperation(StringRef name) const;
+
+  /// Print the contents of this context to the provided stream.
+  void print(raw_ostream &os) const;
+
+private:
+  llvm::StringMap<std::unique_ptr<AttributeConstraint>> attributeConstraints;
+  llvm::StringMap<std::unique_ptr<Dialect>> dialects;
+  llvm::StringMap<std::unique_ptr<TypeConstraint>> typeConstraints;
+};
+} // namespace ods
+} // namespace pdll
+} // namespace mlir
+
+#endif // MLIR_PDL_pdll_ODS_CONTEXT_H_

mlir/include/mlir/Tools/PDLL/ODS/Dialect.h

+//===- Dialect.h - PDLL ODS Dialect -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TOOLS_PDLL_ODS_DIALECT_H_
+#define MLIR_TOOLS_PDLL_ODS_DIALECT_H_
+
+#include <string>
+
+#include "mlir/Support/LLVM.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+
+namespace mlir {
+namespace pdll {
+namespace ods {
+class Operation;
+
+/// This class represents an ODS dialect, and contains information on the
+/// constructs held within the dialect.
+class Dialect {
+public:
+  ~Dialect();
+
+  /// Return the name of this dialect.
+  StringRef getName() const { return name; }
+
+  /// Register a new operation with the context. Returns the inserted operation,
+  /// and a boolean indicating if the operation newly inserted (false if the
+  /// operation already existed).
+  std::pair<Operation *, bool> addOperation(StringRef name, StringRef summary,
+                                            StringRef desc, llvm::SMLoc loc);
+
+  /// Lookup an operation registered with the given name, or null if no
+  /// operation with that name is registered.
+  Operation *lookupOperation(StringRef name) const;
+
+  /// Return a range of all of the registered operations.
+  const llvm::StringMap<std::unique_ptr<Operation>> &getOperations() const {
+    return operations;
+  }
+
+private:
+  explicit Dialect(StringRef name);
+
+  /// The name of the dialect.
+  std::string name;
+
+  /// The operations defined by the dialect.
+  llvm::StringMap<std::unique_ptr<Operation>> operations;
+
+  /// Allow access to the constructor.
+  friend class Context;
+};
+} // namespace ods
+} // namespace pdll
+} // namespace mlir
+
+#endif // MLIR_TOOLS_PDLL_ODS_DIALECT_H_

mlir/include/mlir/Tools/PDLL/ODS/Operation.h

+//===- Operation.h - MLIR PDLL ODS Operation --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TOOLS_PDLL_ODS_OPERATION_H_
+#define MLIR_TOOLS_PDLL_ODS_OPERATION_H_
+
+#include <string>
+
+#include "mlir/Support/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/SMLoc.h"
+
+namespace mlir {
+namespace pdll {
+namespace ods {
+class AttributeConstraint;
+class TypeConstraint;
+
+//===----------------------------------------------------------------------===//
+// VariableLengthKind
+//===----------------------------------------------------------------------===//
+
+enum VariableLengthKind { Single, Optional, Variadic };
+
+//===----------------------------------------------------------------------===//
+// Attribute
+//===----------------------------------------------------------------------===//
+
+/// This class represents an opaque ODS representation of a specific operation
+/// attribute. This includes the name, optionality, and more.
+class Attribute {
+public:
+  /// Return the name of this operand.
+  StringRef getName() const { return name; }
+
+  /// Return true if this attribute is optional.
+  bool isOptional() const { return optional; }
+
+  /// Return the constraint of this attribute.
+  const AttributeConstraint &getConstraint() const { return constraint; }
+
+private:
+  Attribute(StringRef name, bool optional,
+            const AttributeConstraint &constraint)
+      : name(name.str()), optional(optional), constraint(constraint) {}
+
+  /// The ODS name of the attribute.
+  std::string name;
+
+  /// A flag indicating if the attribute is optional.
+  bool optional;
+
+  /// The ODS constraint of this attribute.
+  const AttributeConstraint &constraint;
+
+  /// Allow access to the private constructor.
+  friend class Operation;
+};
+
+//===----------------------------------------------------------------------===//
+// OperandOrResult
+//===----------------------------------------------------------------------===//
+
+/// This class represents an opaque ODS representation of a specific operation
+/// operand or result. This includes the name, variable length flags, and more.
+class OperandOrResult {
+public:
+  /// Return the name of this value.
+  StringRef getName() const { return name; }
+
+  /// Returns true if this value is variadic (Note this is false if the value is
+  /// Optional).
+  bool isVariadic() const {
+    return variableLengthKind == VariableLengthKind::Variadic;
+  }
+
+  /// Returns the variable length kind of this value.
+  VariableLengthKind getVariableLengthKind() const {
+    return variableLengthKind;
+  }
+
+  /// Return the constraint of this value.
+  const TypeConstraint &getConstraint() const { return constraint; }
+
+private:
+  OperandOrResult(StringRef name, VariableLengthKind variableLengthKind,
+                  const TypeConstraint &constraint)
+      : name(name.str()), variableLengthKind(variableLengthKind),
+        constraint(constraint) {}
+
+  /// The ODS name of this value.
+  std::string name;
+
+  /// The variable length kind of this value.
+  VariableLengthKind variableLengthKind;
+
+  /// The ODS constraint of this value.
+  const TypeConstraint &constraint;
+
+  /// Allow access to the private constructor.
+  friend class Operation;
+};
+
+//===----------------------------------------------------------------------===//
+// Operation
+//===----------------------------------------------------------------------===//
+
+/// This class represents an opaque ODS representation of a specific operation.
+/// This includes all of the information necessary for use by the PDL frontend
+/// for generating code for a pattern rewrite.
+class Operation {
+public:
+  /// Return the source location of this operation.
+  SMRange getLoc() const { return location; }
+
+  /// Add an attribute to this operation.
+  void addAttribute(StringRef name, bool optional,
+                    const AttributeConstraint &constraint) {
+    attributes.emplace_back(Attribute(name, optional, constraint));
+  }
+
+  /// Add an operand to this operation.
+  void addOperand(StringRef name, VariableLengthKind variableLengthKind,
+                  const TypeConstraint &constraint) {
+    operands.emplace_back(
+        OperandOrResult(name, variableLengthKind, constraint));
+  }
+
+  /// Add a result to this operation.
+  void addResult(StringRef name, VariableLengthKind variableLengthKind,
+                 const TypeConstraint &constraint) {
+    results.emplace_back(OperandOrResult(name, variableLengthKind, constraint));
+  }
+
+  /// Returns the name of the operation.
+  StringRef getName() const { return name; }
+
+  /// Returns the summary of the operation.
+  StringRef getSummary() const { return summary; }
+
+  /// Returns the description of the operation.
+  StringRef getDescription() const { return description; }
+
+  /// Returns the attributes of this operation.
+  ArrayRef<Attribute> getAttributes() const { return attributes; }
+
+  /// Returns the operands of this operation.
+  ArrayRef<OperandOrResult> getOperands() const { return operands; }
+
+  /// Returns the results of this operation.
+  ArrayRef<OperandOrResult> getResults() const { return results; }
+
+private:
+  Operation(StringRef name, StringRef summary, StringRef desc, SMLoc loc);
+
+  /// The name of the operation.
+  std::string name;
+
+  /// The documentation of the operation.
+  std::string summary;
+  std::string description;
+
+  /// The source location of this operation.
+  SMRange location;
+
+  /// The operands of the operation.
+  SmallVector<OperandOrResult> operands;
+
+  /// The results of the operation.
+  SmallVector<OperandOrResult> results;
+
+  /// The attributes of the operation.
+  SmallVector<Attribute> attributes;
+
+  /// Allow access to the private constructor.
+  friend class Dialect;
+};
+} // namespace ods
+} // namespace pdll
+} // namespace mlir
+
+#endif // MLIR_TOOLS_PDLL_ODS_OPERATION_H_

mlir/lib/TableGen/Constraint.cpp

 }
 
 StringRef Constraint::getSummary() const {
   if (Optional<StringRef> summary = def->getValueAsOptionalString("summary"))
     return *summary;
   return def->getName();
 }
 
+StringRef Constraint::getDefName() const {
+  // Functor used to check a base def in the case where the current def is
+  // anonymous.
+  auto checkBaseDefFn = [&](StringRef baseName) {
+    if (const auto *init = dyn_cast<llvm::DefInit>(def->getValueInit(baseName)))
+      return Constraint(init->getDef(), kind).getDefName();
+    return def->getName();
+  };
+
+  switch (kind) {
+  case CK_Attr:
+    if (def->isAnonymous())
+      return checkBaseDefFn("baseAttr");
+    return def->getName();
+  case CK_Type:
+    if (def->isAnonymous())
+      return checkBaseDefFn("baseType");
+    return def->getName();
+  default:
+    return def->getName();
+  }
+}
+
 AppliedConstraint::AppliedConstraint(Constraint &&constraint,
                                      llvm::StringRef self,
                                      std::vector<std::string> &&entities)
     : constraint(constraint), self(std::string(self)),
       entities(std::move(entities)) {}

mlir/lib/Tools/PDLL/AST/CMakeLists.txt

 add_mlir_library(MLIRPDLLAST
   Context.cpp
   Diagnostic.cpp
   NodePrinter.cpp
   Nodes.cpp
   Types.cpp
 
   LINK_LIBS PUBLIC
+  MLIRPDLLODS
   MLIRSupport
   )

mlir/lib/Tools/PDLL/AST/Context.cpp

 //===- Context.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Tools/PDLL/AST/Context.h"
 #include "TypeDetail.h"
 
 using namespace mlir;
 using namespace mlir::pdll::ast;
 
-Context::Context() {
+Context::Context(ods::Context &odsContext) : odsContext(odsContext) {
   typeUniquer.registerSingletonStorageType<detail::AttributeTypeStorage>();
   typeUniquer.registerSingletonStorageType<detail::ConstraintTypeStorage>();
   typeUniquer.registerSingletonStorageType<detail::RewriteTypeStorage>();
   typeUniquer.registerSingletonStorageType<detail::TypeTypeStorage>();
   typeUniquer.registerSingletonStorageType<detail::ValueTypeStorage>();
 
   typeUniquer.registerParametricStorageType<detail::OperationTypeStorage>();
   typeUniquer.registerParametricStorageType<detail::RangeTypeStorage>();
   typeUniquer.registerParametricStorageType<detail::TupleTypeStorage>();
 }

mlir/lib/Tools/PDLL/CMakeLists.txt

 add_subdirectory(AST)
 add_subdirectory(CodeGen)
+add_subdirectory(ODS)
 add_subdirectory(Parser)

mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp

 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Verifier.h"
 #include "mlir/Parser.h"
 #include "mlir/Tools/PDLL/AST/Context.h"
 #include "mlir/Tools/PDLL/AST/Nodes.h"
 #include "mlir/Tools/PDLL/AST/Types.h"
+#include "mlir/Tools/PDLL/ODS/Context.h"
+#include "mlir/Tools/PDLL/ODS/Operation.h"
 #include "llvm/ADT/ScopedHashTable.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace mlir::pdll;
 
 //===----------------------------------------------------------------------===//
 // CodeGen
 //===----------------------------------------------------------------------===//
 
 namespace {
 class CodeGen {
 public:
   CodeGen(MLIRContext *mlirContext, const ast::Context &context,
           const llvm::SourceMgr &sourceMgr)
-      : builder(mlirContext), sourceMgr(sourceMgr) {
+      : builder(mlirContext), odsContext(context.getODSContext()),
+        sourceMgr(sourceMgr) {
     // Make sure that the PDL dialect is loaded.
     mlirContext->loadDialect<pdl::PDLDialect>();
   }
 
   OwningOpRef<ModuleOp> generate(const ast::Module &module);
 
 private:
   /// Generate an MLIR location from the given source location.
private:
   /// The MLIR builder used for building the resultant IR.
   OpBuilder builder;
 
   /// A map from variable declarations to the MLIR equivalent.
   using VariableMapTy =
       llvm::ScopedHashTable<const ast::VariableDecl *, SmallVector<Value>>;
   VariableMapTy variables;
 
+  /// A reference to the ODS context.
+  const ods::Context &odsContext;
+
   /// The source manager of the PDLL ast.
   const llvm::SourceMgr &sourceMgr;
 };
 } // namespace
 
 OwningOpRef<ModuleOp> CodeGen::generate(const ast::Module &module) {
   OwningOpRef<ModuleOp> mlirModule =
       builder.create<ModuleOp>(genLoc(module.getLoc()));
Value CodeGen::genExprImpl(const ast::MemberAccessExpr *expr) {
   if (ast::OperationType opType = parentType.dyn_cast<ast::OperationType>()) {
     if (isa<ast::AllResultsMemberAccessExpr>(expr)) {
       Type mlirType = genType(expr->getType());
       if (mlirType.isa<pdl::ValueType>())
         return builder.create<pdl::ResultOp>(loc, mlirType, parentExprs[0],
                                              builder.getI32IntegerAttr(0));
       return builder.create<pdl::ResultsOp>(loc, mlirType, parentExprs[0]);
     }
-    llvm_unreachable("unhandled operation member access expression");
+
+    assert(opType.getName() && "expected valid operation name");
+    const ods::Operation *odsOp = odsContext.lookupOperation(*opType.getName());
+    assert(odsOp && "expected valid ODS operation information");
+
+    // Find the result with the member name or by index.
+    ArrayRef<ods::OperandOrResult> results = odsOp->getResults();
+    unsigned resultIndex = results.size();
+    if (llvm::isDigit(name[0])) {
+      name.getAsInteger(/*Radix=*/10, resultIndex);
+    } else {
+      auto findFn = [&](const ods::OperandOrResult &result) {
+        return result.getName() == name;
+      };
+      resultIndex = llvm::find_if(results, findFn) - results.begin();
+    }
+    assert(resultIndex < results.size() && "invalid result index");
+
+    // Generate the result access.
+    IntegerAttr index = builder.getI32IntegerAttr(resultIndex);
+    return builder.create<pdl::ResultsOp>(loc, genType(expr->getType()),
+                                          parentExprs[0], index);
   }
 
   // Handle tuple based member access.
   if (auto tupleType = parentType.dyn_cast<ast::TupleType>()) {
     auto elementNames = tupleType.getElementNames();
 
     // The index is either a numeric index, or a name.
     unsigned index = 0;

mlir/lib/Tools/PDLL/ODS/CMakeLists.txt

+add_mlir_library(MLIRPDLLODS
+  Context.cpp
+  Dialect.cpp
+  Operation.cpp
+
+  LINK_LIBS PUBLIC
+  MLIRSupport
+  )

mlir/lib/Tools/PDLL/ODS/Context.cpp

+//===- Context.cpp --------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Tools/PDLL/ODS/Context.h"
+#include "mlir/Tools/PDLL/ODS/Constraint.h"
+#include "mlir/Tools/PDLL/ODS/Dialect.h"
+#include "mlir/Tools/PDLL/ODS/Operation.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace mlir;
+using namespace mlir::pdll::ods;
+
+//===----------------------------------------------------------------------===//
+// Context
+//===----------------------------------------------------------------------===//
+
+Context::Context() = default;
+Context::~Context() = default;
+
+const AttributeConstraint &Context::addAttributeConstraint(StringRef name,
+                                                           StringRef summary,
+                                                           StringRef cppClass) {
+  std::unique_ptr<AttributeConstraint> &constraint = attributeConstraints[name];
+  if (!constraint)
+    constraint.reset(new AttributeConstraint(name, summary, cppClass));
+  return *constraint;
+}
+
+const TypeConstraint &Context::addTypeConstraint(StringRef name,
+                                                 StringRef summary,
+                                                 StringRef cppClass) {
+  std::unique_ptr<TypeConstraint> &constraint = typeConstraints[name];
+  if (!constraint)
+    constraint.reset(new TypeConstraint(name, summary, cppClass));
+  return *constraint;
+}
+
+Dialect &Context::addDialect(StringRef name) {
+  std::unique_ptr<Dialect> &dialect = dialects[name];
+  if (!dialect)
+    dialect.reset(new Dialect(name));
+  return *dialect;
+}
+
+const Dialect *Context::lookupDialect(StringRef name) const {
+  auto it = dialects.find(name);
+  return it == dialects.end() ? nullptr : &*it->second;
+}
+
+std::pair<Operation *, bool> Context::addOperation(StringRef name,
+                                                   StringRef summary,
+                                                   StringRef desc,
+                                                   llvm::SMLoc loc) {
+  std::pair<StringRef, StringRef> dialectAndName = name.split('.');
+  return addDialect(dialectAndName.first)
+      .addOperation(name, summary, desc, loc);
+}
+
+const Operation *Context::lookupOperation(StringRef name) const {
+  std::pair<StringRef, StringRef> dialectAndName = name.split('.');
+  if (const Dialect *dialect = lookupDialect(dialectAndName.first))
+    return dialect->lookupOperation(name);
+  return nullptr;
+}
+
+template <typename T>
+SmallVector<T *> sortMapByName(const llvm::StringMap<std::unique_ptr<T>> &map) {
+  SmallVector<T *> storage;
+  for (auto &entry : map)
+    storage.push_back(entry.second.get());
+  llvm::sort(storage, [](const auto &lhs, const auto &rhs) {
+    return lhs->getName() < rhs->getName();
+  });
+  return storage;
+}
+
+void Context::print(raw_ostream &os) const {
+  auto printVariableLengthCst = [&](StringRef cst, VariableLengthKind kind) {
+    switch (kind) {
+    case VariableLengthKind::Optional:
+      os << "Optional<" << cst << ">";
+      break;
+    case VariableLengthKind::Single:
+      os << cst;
+      break;
+    case VariableLengthKind::Variadic:
+      os << "Variadic<" << cst << ">";
+      break;
+    }
+  };
+
+  os << "ODSContext {\n";
+  for (const Dialect *dialect : sortMapByName(dialects)) {
+    os << "  Dialect `" << dialect->getName() << "` {\n";
+
+    for (const Operation *op : sortMapByName(dialect->getOperations())) {
+      os << "    Operation `" << op->getName() << "` {\n";
+
+      // Attributes.
+      ArrayRef<Attribute> attributes = op->getAttributes();
+      if (!attributes.empty()) {
+        os << "      Attributes { ";
+        llvm::interleaveComma(attributes, os, [&](const Attribute &attr) {
+          os << attr.getName() << " : ";
+
+          auto kind = attr.isOptional() ? VariableLengthKind::Optional
+                                        : VariableLengthKind::Single;
+          printVariableLengthCst(attr.getConstraint().getName(), kind);
+        });
+        os << " }\n";
+      }
+
+      // Operands.
+      ArrayRef<OperandOrResult> operands = op->getOperands();
+      if (!operands.empty()) {
+        os << "      Operands { ";
+        llvm::interleaveComma(
+            operands, os, [&](const OperandOrResult &operand) {
+              os << operand.getName() << " : ";
+              printVariableLengthCst(operand.getConstraint().getName(),
+                                     operand.getVariableLengthKind());
+            });
+        os << " }\n";
+      }
+
+      // Results.
+      ArrayRef<OperandOrResult> results = op->getResults();
+      if (!results.empty()) {
+        os << "      Results { ";
+        llvm::interleaveComma(results, os, [&](const OperandOrResult &result) {
+          os << result.getName() << " : ";
+          printVariableLengthCst(result.getConstraint().getName(),
+                                 result.getVariableLengthKind());
+        });
+        os << " }\n";
+      }
+
+      os << "    }\n";
+    }
+    os << "  }\n";
+  }
+  for (const AttributeConstraint *cst : sortMapByName(attributeConstraints)) {
+    os << "  AttributeConstraint `" << cst->getName() << "` {\n";
+    os << "    Summary: " << cst->getSummary() << "\n";
+    os << "    CppClass: " << cst->getCppClass() << "\n";
+    os << "  }\n";
+  }
+  for (const TypeConstraint *cst : sortMapByName(typeConstraints)) {
+    os << "  TypeConstraint `" << cst->getName() << "` {\n";
+    os << "    Summary: " << cst->getSummary() << "\n";
+    os << "    CppClass: " << cst->getCppClass() << "\n";
+    os << "  }\n";
+  }
+
+  os << "}\n";
+}

mlir/lib/Tools/PDLL/ODS/Dialect.cpp

+//===- Dialect.cpp --------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Tools/PDLL/ODS/Dialect.h"
+#include "mlir/Tools/PDLL/ODS/Constraint.h"
+#include "mlir/Tools/PDLL/ODS/Operation.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace mlir;
+using namespace mlir::pdll::ods;
+
+//===----------------------------------------------------------------------===//
+// Dialect
+//===----------------------------------------------------------------------===//
+
+Dialect::Dialect(StringRef name) : name(name.str()) {}
+Dialect::~Dialect() = default;
+
+std::pair<Operation *, bool> Dialect::addOperation(StringRef name,
+                                                   StringRef summary,
+                                                   StringRef desc,
+                                                   llvm::SMLoc loc) {
+  std::unique_ptr<Operation> &operation = operations[name];
+  if (operation)
+    return std::make_pair(&*operation, /*wasInserted*/ false);
+
+  operation.reset(new Operation(name, summary, desc, loc));
+  return std::make_pair(&*operation, /*wasInserted*/ true);
+}
+
+Operation *Dialect::lookupOperation(StringRef name) const {
+  auto it = operations.find(name);
+  return it != operations.end() ? it->second.get() : nullptr;
+}

mlir/lib/Tools/PDLL/ODS/Operation.cpp

+//===- Operation.cpp ------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Tools/PDLL/ODS/Operation.h"
+#include "mlir/Support/IndentedOstream.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace mlir;
+using namespace mlir::pdll::ods;
+
+//===----------------------------------------------------------------------===//
+// Operation
+//===----------------------------------------------------------------------===//
+
+Operation::Operation(StringRef name, StringRef summary, StringRef desc,
+                     llvm::SMLoc loc)
+    : name(name.str()), summary(summary.str()),
+      location(loc, llvm::SMLoc::getFromPointer(loc.getPointer() + 1)) {
+  llvm::raw_string_ostream descOS(description);
+  raw_indented_ostream(descOS).printReindented(desc.rtrim(" \t"));
+}

mlir/lib/Tools/PDLL/Parser/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Support
+  TableGen
+)
+
 add_mlir_library(MLIRPDLLParser
   Lexer.cpp
   Parser.cpp
 
   LINK_LIBS PUBLIC
   MLIRPDLLAST
   MLIRSupport
+  MLIRTableGen
   )

mlir/lib/Tools/PDLL/Parser/Parser.cpp

 //===- Parser.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Tools/PDLL/Parser/Parser.h"
 #include "Lexer.h"
 #include "mlir/Support/LogicalResult.h"
+#include "mlir/TableGen/Argument.h"
+#include "mlir/TableGen/Attribute.h"
+#include "mlir/TableGen/Constraint.h"
+#include "mlir/TableGen/Format.h"
+#include "mlir/TableGen/Operator.h"
 #include "mlir/Tools/PDLL/AST/Context.h"
 #include "mlir/Tools/PDLL/AST/Diagnostic.h"
 #include "mlir/Tools/PDLL/AST/Nodes.h"
 #include "mlir/Tools/PDLL/AST/Types.h"
+#include "mlir/Tools/PDLL/ODS/Constraint.h"
+#include "mlir/Tools/PDLL/ODS/Context.h"
+#include "mlir/Tools/PDLL/ODS/Operation.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/ScopedPrinter.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Parser.h"
 #include <string>
 
 using namespace mlir;
 using namespace mlir::pdll;
 
 //===----------------------------------------------------------------------===//
 // Parser
 //===----------------------------------------------------------------------===//
 
 namespace {
 class Parser {
 public:
   Parser(ast::Context &ctx, llvm::SourceMgr &sourceMgr)
       : ctx(ctx), lexer(sourceMgr, ctx.getDiagEngine()),
         curToken(lexer.lexToken()), curDeclScope(nullptr),
         valueTy(ast::ValueType::get(ctx)),
         valueRangeTy(ast::ValueRangeType::get(ctx)),
         typeTy(ast::TypeType::get(ctx)),
-        typeRangeTy(ast::TypeRangeType::get(ctx)) {}
+        typeRangeTy(ast::TypeRangeType::get(ctx)),
+        attrTy(ast::AttributeType::get(ctx)) {}
 
   /// Try to parse a new module. Returns nullptr in the case of failure.
   FailureOr<ast::Module *> parseModule();
 
 private:
   /// The current context of the parser. It allows for the parser to know a bit
   /// about the construct it is nested within during parsing. This is used
   /// specifically to provide additional verification during parsing, e.g. to
ast::DeclScope *pushDeclScope() {
     return (curDeclScope = newScope);
   }
   void pushDeclScope(ast::DeclScope *scope) { curDeclScope = scope; }
 
   /// Pop the last decl scope from the lexer.
   void popDeclScope() { curDeclScope = curDeclScope->getParentScope(); }
 
   /// Parse the body of an AST module.
-  LogicalResult parseModuleBody(SmallVector<ast::Decl *> &decls);
+  LogicalResult parseModuleBody(SmallVectorImpl<ast::Decl *> &decls);
 
   /// Try to convert the given expression to `type`. Returns failure and emits
   /// an error if a conversion is not viable. On failure, `noteAttachFn` is
   /// invoked to attach notes to the emitted error diagnostic. On success,
   /// `expr` is updated to the expression used to convert to `type`.
   LogicalResult convertExpressionTo(
       ast::Expr *&expr, ast::Type type,
       function_ref<void(ast::Diagnostic &diag)> noteAttachFn = {});
 
   /// Given an operation expression, convert it to a Value or ValueRange
   /// typed expression.
   ast::Expr *convertOpToValue(const ast::Expr *opExpr);
 
+  /// Lookup ODS information for the given operation, returns nullptr if no
+  /// information is found.
+  const ods::Operation *lookupODSOperation(Optional<StringRef> opName) {
+    return opName ? ctx.getODSContext().lookupOperation(*opName) : nullptr;
+  }
+
   //===--------------------------------------------------------------------===//
   // Directives
 
-  LogicalResult parseDirective(SmallVector<ast::Decl *> &decls);
-  LogicalResult parseInclude(SmallVector<ast::Decl *> &decls);
+  LogicalResult parseDirective(SmallVectorImpl<ast::Decl *> &decls);
+  LogicalResult parseInclude(SmallVectorImpl<ast::Decl *> &decls);
+  LogicalResult parseTdInclude(StringRef filename, SMRange fileLoc,
+                               SmallVectorImpl<ast::Decl *> &decls);
+
+  /// Process the records of a parsed tablegen include file.
+  void processTdIncludeRecords(llvm::RecordKeeper &tdRecords,
+                               SmallVectorImpl<ast::Decl *> &decls);
+
+  /// Create a user defined native constraint for a constraint imported from
+  /// ODS.
+  template <typename ConstraintT>
+  ast::Decl *createODSNativePDLLConstraintDecl(StringRef name,
+                                               StringRef codeBlock, SMRange loc,
+                                               ast::Type type);
+  template <typename ConstraintT>
+  ast::Decl *
+  createODSNativePDLLConstraintDecl(const tblgen::Constraint &constraint,
+                                    SMRange loc, ast::Type type);
 
   //===--------------------------------------------------------------------===//
   // Decls
 
   /// This structure contains the set of pattern metadata that may be parsed.
   struct ParsedPatternMetadata {
     Optional<uint16_t> benefit;
     bool hasBoundedRecursion = false;
FailureOr<ast::Type> validateMemberAccess(ast::Expr *parentExpr,
                                             StringRef name, SMRange loc);
   FailureOr<ast::OperationExpr *>
   createOperationExpr(SMRange loc, const ast::OpNameDecl *name,
                       MutableArrayRef<ast::Expr *> operands,
                       MutableArrayRef<ast::NamedAttributeDecl *> attributes,
                       MutableArrayRef<ast::Expr *> results);
   LogicalResult
   validateOperationOperands(SMRange loc, Optional<StringRef> name,
+                            const ods::Operation *odsOp,
                             MutableArrayRef<ast::Expr *> operands);
   LogicalResult validateOperationResults(SMRange loc, Optional<StringRef> name,
+                                         const ods::Operation *odsOp,
                                          MutableArrayRef<ast::Expr *> results);
-  LogicalResult
-  validateOperationOperandsOrResults(SMRange loc, Optional<StringRef> name,
-                                     MutableArrayRef<ast::Expr *> values,
-                                     ast::Type singleTy, ast::Type rangeTy);
+  LogicalResult validateOperationOperandsOrResults(
+      StringRef groupName, SMRange loc, Optional<SMRange> odsOpLoc,
+      Optional<StringRef> name, MutableArrayRef<ast::Expr *> values,
+      ArrayRef<ods::OperandOrResult> odsValues, ast::Type singleTy,
+      ast::Type rangeTy);
   FailureOr<ast::TupleExpr *> createTupleExpr(SMRange loc,
                                               ArrayRef<ast::Expr *> elements,
                                               ArrayRef<StringRef> elementNames);
 
   //===--------------------------------------------------------------------===//
   // Stmts
 
   FailureOr<ast::EraseStmt *> createEraseStmt(SMRange loc, ast::Expr *rootOp);
private:
   llvm::SpecificBumpPtrAllocator<ast::DeclScope> scopeAllocator;
 
   /// The current context of the parser.
   ParserContext parserContext = ParserContext::Global;
 
   /// Cached types to simplify verification and expression creation.
   ast::Type valueTy, valueRangeTy;
   ast::Type typeTy, typeRangeTy;
+  ast::Type attrTy;
 
   /// A counter used when naming anonymous constraints and rewrites.
   unsigned anonymousDeclNameCounter = 0;
 };
 } // namespace
 
 FailureOr<ast::Module *> Parser::parseModule() {
   SMLoc moduleLoc = curToken.getStartLoc();
   pushDeclScope();
 
   // Parse the top-level decls of the module.
   SmallVector<ast::Decl *> decls;
   if (failed(parseModuleBody(decls)))
     return popDeclScope(), failure();
 
   popDeclScope();
   return ast::Module::create(ctx, moduleLoc, decls);
 }
 
-LogicalResult Parser::parseModuleBody(SmallVector<ast::Decl *> &decls) {
+LogicalResult Parser::parseModuleBody(SmallVectorImpl<ast::Decl *> &decls) {
   while (curToken.isNot(Token::eof)) {
     if (curToken.is(Token::directive)) {
       if (failed(parseDirective(decls)))
         return failure();
       continue;
     }
 
     FailureOr<ast::Decl *> decl = parseTopLevelDecl();
if (auto exprOpType = exprType.dyn_cast<ast::OperationType>()) {
     if (type == valueRangeTy) {
       expr = ast::AllResultsMemberAccessExpr::create(ctx, expr->getLoc(), expr,
                                                      valueRangeTy);
       return success();
     }
 
     // Allow conversion to a single value by constraining the result range.
     if (type == valueTy) {
+      // If the operation is registered, we can verify if it can ever have a
+      // single result.
+      Optional<StringRef> opName = exprOpType.getName();
+      if (const ods::Operation *odsOp = lookupODSOperation(opName)) {
+        if (odsOp->getResults().empty()) {
+          return emitConvertError()->attachNote(
+              llvm::formatv("see the definition of `{0}`, which was defined "
+                            "with zero results",
+                            odsOp->getName()),
+              odsOp->getLoc());
+        }
+
+        unsigned numSingleResults = llvm::count_if(
+            odsOp->getResults(), [](const ods::OperandOrResult &result) {
+              return result.getVariableLengthKind() ==
+                     ods::VariableLengthKind::Single;
+            });
+        if (numSingleResults > 1) {
+          return emitConvertError()->attachNote(
+              llvm::formatv("see the definition of `{0}`, which was defined "
+                            "with at least {1} results",
+                            odsOp->getName(), numSingleResults),
+              odsOp->getLoc());
+        }
+      }
+
       expr = ast::AllResultsMemberAccessExpr::create(ctx, expr->getLoc(), expr,
                                                      valueTy);
       return success();
     }
     return emitConvertError();
   }
 
   // FIXME: Decide how to allow/support converting a single result to multiple,
LogicalResult Parser::convertExpressionTo(
   }
 
   return emitConvertError();
 }
 
 //===----------------------------------------------------------------------===//
 // Directives
 
-LogicalResult Parser::parseDirective(SmallVector<ast::Decl *> &decls) {
+LogicalResult Parser::parseDirective(SmallVectorImpl<ast::Decl *> &decls) {
   StringRef directive = curToken.getSpelling();
   if (directive == "#include")
     return parseInclude(decls);
 
   return emitError("unknown directive `" + directive + "`");
 }
 
-LogicalResult Parser::parseInclude(SmallVector<ast::Decl *> &decls) {
+LogicalResult Parser::parseInclude(SmallVectorImpl<ast::Decl *> &decls) {
   SMRange loc = curToken.getLoc();
   consumeToken(Token::directive);
 
   // Parse the file being included.
   if (!curToken.isString())
     return emitError(loc,
                      "expected string file name after `include` directive");
   SMRange fileLoc = curToken.getLoc();
if (filename.endswith(".pdll")) {
     // finish parsing the nested file.
     Token oldToken = curToken;
     curToken = lexer.lexToken();
     LogicalResult result = parseModuleBody(decls);
     curToken = oldToken;
     return result;
   }
 
-  return emitError(fileLoc, "expected include filename to end with `.pdll`");
+  // Otherwise, this must be a `.td` include.
+  if (filename.endswith(".td"))
+    return parseTdInclude(filename, fileLoc, decls);
+
+  return emitError(fileLoc,
+                   "expected include filename to end with `.pdll` or `.td`");
+}
+
+LogicalResult Parser::parseTdInclude(StringRef filename, llvm::SMRange fileLoc,
+                                     SmallVectorImpl<ast::Decl *> &decls) {
+  llvm::SourceMgr &parserSrcMgr = lexer.getSourceMgr();
+
+  // This class provides a context argument for the llvm::SourceMgr diagnostic
+  // handler.
+  struct DiagHandlerContext {
+    Parser &parser;
+    StringRef filename;
+    llvm::SMRange loc;
+  } handlerContext{*this, filename, fileLoc};
+
+  // Set the diagnostic handler for the tablegen source manager.
+  llvm::SrcMgr.setDiagHandler(
+      [](const llvm::SMDiagnostic &diag, void *rawHandlerContext) {
+        auto *ctx = reinterpret_cast<DiagHandlerContext *>(rawHandlerContext);
+        (void)ctx->parser.emitError(
+            ctx->loc,
+            llvm::formatv("error while processing include file `{0}`: {1}",
+                          ctx->filename, diag.getMessage()));
+      },
+      &handlerContext);
+
+  auto processFn = [&](llvm::RecordKeeper &records) {
+    processTdIncludeRecords(records, decls);
+
+    // After we are done processing, move all of the tablegen source buffers to
+    // the main parser source mgr. This allows for directly using source
+    // locations from the .td files without needing to remap them.
+    parserSrcMgr.takeSourceBuffersFrom(llvm::SrcMgr);
+    return false;
+  };
+  // Use a temporary buffer with a nested include file to let TableGen handle
+  // finding the location of and opening the include file.
+  std::string tempBuffer = llvm::formatv("include \"{0}\"\n", filename).str();
+  if (llvm::TableGenParseFile(
+          llvm::MemoryBuffer::getMemBuffer(tempBuffer, "<pdll_td_include>"),
+          parserSrcMgr.getIncludeDirs(), processFn))
+    return failure();
+
+  return success();
+}
+
+void Parser::processTdIncludeRecords(llvm::RecordKeeper &tdRecords,
+                                     SmallVectorImpl<ast::Decl *> &decls) {
+  // Return the length kind of the given value.
+  auto getLengthKind = [](const auto &value) {
+    if (value.isOptional())
+      return ods::VariableLengthKind::Optional;
+    return value.isVariadic() ? ods::VariableLengthKind::Variadic
+                              : ods::VariableLengthKind::Single;
+  };
+
+  // Insert a type constraint into the ODS context.
+  ods::Context &odsContext = ctx.getODSContext();
+  auto addTypeConstraint = [&](const tblgen::NamedTypeConstraint &cst)
+      -> const ods::TypeConstraint & {
+    return odsContext.addTypeConstraint(cst.constraint.getDefName(),
+                                        cst.constraint.getSummary(),
+                                        cst.constraint.getCPPClassName());
+  };
+  auto convertLocToRange = [&](llvm::SMLoc loc) -> llvm::SMRange {
+    return {loc, llvm::SMLoc::getFromPointer(loc.getPointer() + 1)};
+  };
+
+  // Process the parsed tablegen records to build ODS information.
+  /// Operations.
+  for (llvm::Record *def : tdRecords.getAllDerivedDefinitions("Op")) {
+    tblgen::Operator op(def);
+
+    bool inserted = false;
+    ods::Operation *odsOp = nullptr;
+    std::tie(odsOp, inserted) =
+        odsContext.addOperation(op.getOperationName(), op.getSummary(),
+                                op.getDescription(), op.getLoc().front());
+
+    // Ignore operations that have already been added.
+    if (!inserted)
+      continue;
+
+    for (const tblgen::NamedAttribute &attr : op.getAttributes()) {
+      odsOp->addAttribute(
+          attr.name, attr.attr.isOptional(),
+          odsContext.addAttributeConstraint(attr.attr.getAttrDefName(),
+                                            attr.attr.getSummary(),
+                                            attr.attr.getStorageType()));
+    }
+    for (const tblgen::NamedTypeConstraint &operand : op.getOperands()) {
+      odsOp->addOperand(operand.name, getLengthKind(operand),
+                        addTypeConstraint(operand));
+    }
+    for (const tblgen::NamedTypeConstraint &result : op.getResults()) {
+      odsOp->addResult(result.name, getLengthKind(result),
+                       addTypeConstraint(result));
+    }
+  }
+  /// Attr constraints.
+  for (llvm::Record *def : tdRecords.getAllDerivedDefinitions("Attr")) {
+    if (!def->isAnonymous() && !curDeclScope->lookup(def->getName())) {
+      decls.push_back(
+          createODSNativePDLLConstraintDecl<ast::AttrConstraintDecl>(
+              tblgen::AttrConstraint(def),
+              convertLocToRange(def->getLoc().front()), attrTy));
+    }
+  }
+  /// Type constraints.
+  for (llvm::Record *def : tdRecords.getAllDerivedDefinitions("Type")) {
+    if (!def->isAnonymous() && !curDeclScope->lookup(def->getName())) {
+      decls.push_back(
+          createODSNativePDLLConstraintDecl<ast::TypeConstraintDecl>(
+              tblgen::TypeConstraint(def),
+              convertLocToRange(def->getLoc().front()), typeTy));
+    }
+  }
+  /// Interfaces.
+  ast::Type opTy = ast::OperationType::get(ctx);
+  for (llvm::Record *def : tdRecords.getAllDerivedDefinitions("Interface")) {
+    StringRef name = def->getName();
+    if (def->isAnonymous() || curDeclScope->lookup(name) ||
+        def->isSubClassOf("DeclareInterfaceMethods"))
+      continue;
+    SMRange loc = convertLocToRange(def->getLoc().front());
+
+    StringRef className = def->getValueAsString("cppClassName");
+    StringRef cppNamespace = def->getValueAsString("cppNamespace");
+    std::string codeBlock =
+        llvm::formatv("llvm::isa<{0}::{1}>(self)", cppNamespace, className)
+            .str();
+
+    if (def->isSubClassOf("OpInterface")) {
+      decls.push_back(createODSNativePDLLConstraintDecl<ast::OpConstraintDecl>(
+          name, codeBlock, loc, opTy));
+    } else if (def->isSubClassOf("AttrInterface")) {
+      decls.push_back(
+          createODSNativePDLLConstraintDecl<ast::AttrConstraintDecl>(
+              name, codeBlock, loc, attrTy));
+    } else if (def->isSubClassOf("TypeInterface")) {
+      decls.push_back(
+          createODSNativePDLLConstraintDecl<ast::TypeConstraintDecl>(
+              name, codeBlock, loc, typeTy));
+    }
+  }
+}
+
+template <typename ConstraintT>
+ast::Decl *
+Parser::createODSNativePDLLConstraintDecl(StringRef name, StringRef codeBlock,
+                                          SMRange loc, ast::Type type) {
+  // Build the single input parameter.
+  ast::DeclScope *argScope = pushDeclScope();
+  auto *paramVar = ast::VariableDecl::create(
+      ctx, ast::Name::create(ctx, "self", loc), type,
+      /*initExpr=*/nullptr, ast::ConstraintRef(ConstraintT::create(ctx, loc)));
+  argScope->add(paramVar);
+  popDeclScope();
+
+  // Build the native constraint.
+  auto *constraintDecl = ast::UserConstraintDecl::createNative(
+      ctx, ast::Name::create(ctx, name, loc), paramVar,
+      /*results=*/llvm::None, codeBlock, ast::TupleType::get(ctx));
+  curDeclScope->add(constraintDecl);
+  return constraintDecl;
+}
+
+template <typename ConstraintT>
+ast::Decl *
+Parser::createODSNativePDLLConstraintDecl(const tblgen::Constraint &constraint,
+                                          SMRange loc, ast::Type type) {
+  // Format the condition template.
+  tblgen::FmtContext fmtContext;
+  fmtContext.withSelf("self");
+  std::string codeBlock =
+      tblgen::tgfmt(constraint.getConditionTemplate(), &fmtContext);
+
+  return createODSNativePDLLConstraintDecl<ConstraintT>(constraint.getDefName(),
+                                                        codeBlock, loc, type);
 }
 
 //===----------------------------------------------------------------------===//
 // Decls
 
 FailureOr<ast::Decl *> Parser::parseTopLevelDecl() {
   FailureOr<ast::Decl *> decl;
   switch (curToken.getKind()) {
if (failed(memberType))
     return failure();
 
   return ast::MemberAccessExpr::create(ctx, loc, parentExpr, name, *memberType);
 }
 
 FailureOr<ast::Type> Parser::validateMemberAccess(ast::Expr *parentExpr,
                                                   StringRef name, SMRange loc) {
   ast::Type parentType = parentExpr->getType();
-  if (parentType.isa<ast::OperationType>()) {
+  if (ast::OperationType opType = parentType.dyn_cast<ast::OperationType>()) {
     if (name == ast::AllResultsMemberAccessExpr::getMemberName())
       return valueRangeTy;
+
+    // Verify member access based on the operation type.
+    if (const ods::Operation *odsOp = lookupODSOperation(opType.getName())) {
+      auto results = odsOp->getResults();
+
+      // Handle indexed results.
+      unsigned index = 0;
+      if (llvm::isDigit(name[0]) && !name.getAsInteger(/*Radix=*/10, index) &&
+          index < results.size()) {
+        return results[index].isVariadic() ? valueRangeTy : valueTy;
+      }
+
+      // Handle named results.
+      const auto *it = llvm::find_if(results, [&](const auto &result) {
+        return result.getName() == name;
+      });
+      if (it != results.end())
+        return it->isVariadic() ? valueRangeTy : valueTy;
+    }
+
   } else if (auto tupleType = parentType.dyn_cast<ast::TupleType>()) {
     // Handle indexed results.
     unsigned index = 0;
     if (llvm::isDigit(name[0]) && !name.getAsInteger(/*Radix=*/10, index) &&
         index < tupleType.size()) {
       return tupleType.getElementTypes()[index];
     }
 

 }
 
 FailureOr<ast::OperationExpr *> Parser::createOperationExpr(
     SMRange loc, const ast::OpNameDecl *name,
     MutableArrayRef<ast::Expr *> operands,
     MutableArrayRef<ast::NamedAttributeDecl *> attributes,
     MutableArrayRef<ast::Expr *> results) {
   Optional<StringRef> opNameRef = name->getName();
+  const ods::Operation *odsOp = lookupODSOperation(opNameRef);
 
   // Verify the inputs operands.
-  if (failed(validateOperationOperands(loc, opNameRef, operands)))
+  if (failed(validateOperationOperands(loc, opNameRef, odsOp, operands)))
     return failure();
 
   // Verify the attribute list.
   for (ast::NamedAttributeDecl *attr : attributes) {
     // Check for an attribute type, or a type awaiting resolution.
     ast::Type attrType = attr->getValue()->getType();
     if (!attrType.isa<ast::AttributeType>()) {
       return emitError(
           attr->getValue()->getLoc(),
           llvm::formatv("expected `Attr` expression, but got `{0}`", attrType));
     }
   }
 
   // Verify the result types.
-  if (failed(validateOperationResults(loc, opNameRef, results)))
+  if (failed(validateOperationResults(loc, opNameRef, odsOp, results)))
     return failure();
 
   return ast::OperationExpr::create(ctx, loc, name, operands, results,
                                     attributes);
 }
 
 LogicalResult
 Parser::validateOperationOperands(SMRange loc, Optional<StringRef> name,
+                                  const ods::Operation *odsOp,
                                   MutableArrayRef<ast::Expr *> operands) {
-  return validateOperationOperandsOrResults(loc, name, operands, valueTy,
-                                            valueRangeTy);
+  return validateOperationOperandsOrResults(
+      "operand", loc, odsOp ? odsOp->getLoc() : Optional<SMRange>(), name,
+      operands, odsOp ? odsOp->getOperands() : llvm::None, valueTy,
 }
 
 LogicalResult
 Parser::validateOperationResults(SMRange loc, Optional<StringRef> name,
+                                 const ods::Operation *odsOp,
                                  MutableArrayRef<ast::Expr *> results) {
-  return validateOperationOperandsOrResults(loc, name, results, typeTy,
-                                            typeRangeTy);
+  return validateOperationOperandsOrResults(
+      "result", loc, odsOp ? odsOp->getLoc() : Optional<SMRange>(), name,
+      results, odsOp ? odsOp->getResults() : llvm::None, typeTy, typeRangeTy);
 }
 
 LogicalResult Parser::validateOperationOperandsOrResults(
-    SMRange loc, Optional<StringRef> name, MutableArrayRef<ast::Expr *> values,
-    ast::Type singleTy, ast::Type rangeTy) {
+    StringRef groupName, SMRange loc, Optional<SMRange> odsOpLoc,
+    Optional<StringRef> name, MutableArrayRef<ast::Expr *> values,
+    ArrayRef<ods::OperandOrResult> odsValues, ast::Type singleTy,
+    ast::Type rangeTy) {
   // All operation types accept a single range parameter.
   if (values.size() == 1) {
     if (failed(convertExpressionTo(values[0], rangeTy)))
       return failure();
     return success();
   }
 
+  /// If the operation has ODS information, we can more accurately verify the
+  /// values.
+  if (odsOpLoc) {
+    if (odsValues.size() != values.size()) {
+      return emitErrorAndNote(
+          loc,
+          llvm::formatv("invalid number of {0} groups for `{1}`; expected "
+                        "{2}, but got {3}",
+                        groupName, *name, odsValues.size(), values.size()),
+          *odsOpLoc, llvm::formatv("see the definition of `{0}` here", *name));
+    }
+    auto diagFn = [&](ast::Diagnostic &diag) {
+      diag.attachNote(llvm::formatv("see the definition of `{0}` here", *name),
+                      *odsOpLoc);
+    };
+    for (unsigned i = 0, e = values.size(); i < e; ++i) {
+      ast::Type expectedType = odsValues[i].isVariadic() ? rangeTy : singleTy;
+      if (failed(convertExpressionTo(values[i], expectedType, diagFn)))
+        return failure();
+    }
+    return success();
+  }
+
   // Otherwise, accept the value groups as they have been defined and just
   // ensure they are one of the expected types.
   for (ast::Expr *&valueExpr : values) {
     ast::Type valueExprType = valueExpr->getType();
 
     // Check if this is one of the expected types.
     if (valueExprType == rangeTy || valueExprType == singleTy)
       continue;

mlir/test/mlir-pdll/CodeGen/MLIR/expr.pdll

-// RUN: mlir-pdll %s -I %S -split-input-file -x mlir | FileCheck %s
+// RUN: mlir-pdll %s -I %S -I %S/../../../../include -split-input-file -x mlir | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // AttributeExpr
 //===----------------------------------------------------------------------===//
 
 // CHECK: pdl.pattern @AttrExpr
 // CHECK: %[[ATTR:.*]] = attribute 10
 // CHECK: operation({{.*}}) {"attr" = %[[ATTR]]}

 Pattern OpAllResultMemberAccess {
   let singleVar: Value = op<>;
   let rangeVar: ValueRange = op<>;
   erase op<>(singleVar, rangeVar);
 }
 
 // -----
 
+// Handle implicit "named" operation results access.
+
+#include "include/ops.td"
+
+// CHECK: pdl.pattern @OpResultMemberAccess
+// CHECK: %[[OP0:.*]] = operation
+// CHECK: %[[RES:.*]] = results 0 of %[[OP0]] -> !pdl.value
+// CHECK: %[[RES1:.*]] = results 0 of %[[OP0]] -> !pdl.value
+// CHECK: %[[RES2:.*]] = results 1 of %[[OP0]] -> !pdl.range<value>
+// CHECK: %[[RES3:.*]] = results 1 of %[[OP0]] -> !pdl.range<value>
+// CHECK: operation(%[[RES]], %[[RES1]], %[[RES2]], %[[RES3]] : !pdl.value, !pdl.value, !pdl.range<value>, !pdl.range<value>)
+Pattern OpResultMemberAccess {
+  let op: Op<test.with_results>;
+  erase op<>(op.0, op.result, op.1, op.var_result);
+}
+
+// -----
+
 // CHECK: pdl.pattern @TupleMemberAccessNumber
 // CHECK: %[[FIRST:.*]] = operation "test.first"
 // CHECK: %[[SECOND:.*]] = operation "test.second"
 // CHECK: rewrite %[[FIRST]] {
 // CHECK:   replace %[[FIRST]] with %[[SECOND]]
 Pattern TupleMemberAccessNumber {
   let firstOp = op<test.first>;
   let secondOp = op<test.second>(firstOp);

mlir/test/mlir-pdll/CodeGen/MLIR/include/ops.td

+include "mlir/IR/OpBase.td"
+
+def Test_Dialect : Dialect {
+  let name = "test";
+}
+
+def OpWithResults : Op<Test_Dialect, "with_results"> {
+  let results = (outs I64:$result, Variadic<I64>:$var_result);
+}

mlir/test/mlir-pdll/Parser/directive-failure.pdll

 
 // -----
 
 // CHECK: unable to open include file `unknown_file.pdll`
 #include "unknown_file.pdll"
 
 // -----
 
-// CHECK: expected include filename to end with `.pdll`
+// CHECK: expected include filename to end with `.pdll` or `.td`
 #include "unknown_file.foo"

mlir/test/mlir-pdll/Parser/expr-failure.pdll

-// RUN: not mlir-pdll %s -split-input-file 2>&1 | FileCheck %s
+// RUN: not mlir-pdll %s -I %S -I %S/../../../include -split-input-file 2>&1 | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // Reference Expr
 //===----------------------------------------------------------------------===//
 
 Pattern {
   // CHECK: expected identifier constraint
   let foo = Foo: ;

 Pattern {
   // CHECK: expected `)` after operation result type list
   let value: TypeRange;
   let foo = op<> -> (value<;
 }
 
 // -----
 
+#include "include/ops.td"
+
+Pattern {
+  // CHECK: invalid number of operand groups for `test.all_empty`; expected 0, but got 2
+  // CHECK: see the definition of `test.all_empty` here
+  let foo = op<test.all_empty>(operand1: Value, operand2: Value);
+}
+
+// -----
+
+#include "include/ops.td"
+
+Pattern {
+  // CHECK: invalid number of result groups for `test.all_empty`; expected 0, but got 2
+  // CHECK: see the definition of `test.all_empty` here
+  let foo = op<test.all_empty> -> (result1: Type, result2: Type);
+}
+
+// -----
+
 //===----------------------------------------------------------------------===//
 // `type` Expr
 //===----------------------------------------------------------------------===//
 
 Pattern {
   // CHECK: expected string literal containing MLIR type
   let foo = type<foo;
 }
 
 // -----
 
 Pattern {
   // CHECK: expected `>` after type literal
   let foo = type<"";
 }

mlir/test/mlir-pdll/Parser/expr.pdll

-// RUN: mlir-pdll %s -I %S -split-input-file | FileCheck %s
+// RUN: mlir-pdll %s -I %S -I %S/../../../include -split-input-file | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // AttrExpr
 //===----------------------------------------------------------------------===//
 
 // CHECK: Module
 // CHECK: `-AttributeExpr {{.*}} Value<"10: i32">
 Pattern {
Pattern {
   let firstEltIndex = tuple.0;
   let firstEltName = tuple.firstElt;
 
   erase _: Op;
 }
 
 // -----
 
+#include "include/ops.td"
+
+// CHECK: Module
+// CHECK: `-VariableDecl {{.*}} Name<firstEltIndex> Type<Value>
+// CHECK:   `-MemberAccessExpr {{.*}} Member<0> Type<Value>
+// CHECK:     `-DeclRefExpr {{.*}} Type<Op<test.all_single>>
+// CHECK: `-VariableDecl {{.*}} Name<firstEltName> Type<Value>
+// CHECK:   `-MemberAccessExpr {{.*}} Member<result> Type<Value>
+// CHECK:     `-DeclRefExpr {{.*}} Type<Op<test.all_single>>
+Pattern {
+  let op: Op<test.all_single>;
+  let firstEltIndex = op.0;
+  let firstEltName = op.result;
+
+  erase op;
+}
+
+// -----
+
 //===----------------------------------------------------------------------===//
 // OperationExpr
 //===----------------------------------------------------------------------===//
 
 // Test a non-constrained operation expression, and ensure that we don't treat
 // unconstrained as "not present"(e.g. zero operands).
 
 // CHECK: Module

mlir/test/mlir-pdll/Parser/include/interfaces.td

+include "mlir/IR/OpBase.td"
+
+def TestAttrInterface : AttrInterface<"TestAttrInterface">;
+def TestOpInterface : OpInterface<"TestOpInterface">;
+def TestTypeInterface : TypeInterface<"TestTypeInterface">;

mlir/test/mlir-pdll/Parser/include/ops.td

+include "include/interfaces.td"
+
+def Test_Dialect : Dialect {
+  let name = "test";
+}
+
+def OpAllEmpty : Op<Test_Dialect, "all_empty">;
+
+def OpAllSingle : Op<Test_Dialect, "all_single"> {
+  let arguments = (ins I64:$operand, I64Attr:$attr);
+  let results = (outs I64:$result);
+}
+
+def OpAllOptional : Op<Test_Dialect, "all_optional"> {
+  let arguments = (ins Optional<I64>:$operand, OptionalAttr<I64Attr>:$attr);
+  let results = (outs Optional<I64>:$result);
+}
+
+def OpAllVariadic : Op<Test_Dialect, "all_variadic"> {
+  let arguments = (ins Variadic<I64>:$operands);
+  let results = (outs Variadic<I64>:$results);
+}
+
+def OpMultipleSingleResult : Op<Test_Dialect, "multiple_single_result"> {
+  let results = (outs I64:$result, I64:$result2);
+}

mlir/test/mlir-pdll/Parser/include_td.pdll

+// RUN: mlir-pdll %s -I %S -I %S/../../../include -dump-ods 2>&1 | FileCheck %s
+
+#include "include/ops.td"
+
+// CHECK:      Operation `test.all_empty` {
+// CHECK-NEXT: }
+
+// CHECK:      Operation `test.all_optional` {
+// CHECK-NEXT:   Attributes { attr : Optional<I64Attr> }
+// CHECK-NEXT:   Operands { operand : Optional<I64> }
+// CHECK-NEXT:   Results { result : Optional<I64> }
+// CHECK-NEXT: }
+
+// CHECK:      Operation `test.all_single` {
+// CHECK-NEXT:   Attributes { attr : I64Attr }
+// CHECK-NEXT:   Operands { operand : I64 }
+// CHECK-NEXT:   Results { result : I64 }
+// CHECK-NEXT: }
+
+// CHECK:      Operation `test.all_variadic` {
+// CHECK-NEXT:   Operands { operands : Variadic<I64> }
+// CHECK-NEXT:   Results { results : Variadic<I64> }
+// CHECK-NEXT: }
+  
+// CHECK:      AttributeConstraint `I64Attr` {
+// CHECK-NEXT:   Summary: 64-bit signless integer attribute
+// CHECK-NEXT:   CppClass: ::mlir::IntegerAttr
+// CHECK-NEXT: }
+
+// CHECK:      TypeConstraint `I64` {
+// CHECK-NEXT:   Summary: 64-bit signless integer
+// CHECK-NEXT:   CppClass: ::mlir::IntegerType
+// CHECK-NEXT: }
+
+// CHECK: UserConstraintDecl {{.*}} Name<TestAttrInterface> ResultType<Tuple<>> Code<llvm::isa<::TestAttrInterface>(self)>
+// CHECK:  `Inputs`
+// CHECK:    `-VariableDecl {{.*}} Name<self> Type<Attr>
+// CHECK:      `Constraints`
+// CHECK:        `-AttrConstraintDecl
+
+// CHECK: UserConstraintDecl {{.*}} Name<TestOpInterface> ResultType<Tuple<>> Code<llvm::isa<::TestOpInterface>(self)>
+// CHECK:  `Inputs`
+// CHECK:    `-VariableDecl {{.*}} Name<self> Type<Op>
+// CHECK:      `Constraints`
+// CHECK:        `-OpConstraintDecl
+// CHECK:          `-OpNameDecl
+
+// CHECK: UserConstraintDecl {{.*}} Name<TestTypeInterface> ResultType<Tuple<>> Code<llvm::isa<::TestTypeInterface>(self)>
+// CHECK:  `Inputs`
+// CHECK:    `-VariableDecl {{.*}} Name<self> Type<Type>
+// CHECK:      `Constraints`
+// CHECK:        `-TypeConstraintDecl {{.*}}

mlir/test/mlir-pdll/Parser/stmt-failure.pdll

-// RUN: not mlir-pdll %s -split-input-file 2>&1 | FileCheck %s
+// RUN: not mlir-pdll %s -I %S -I %S/../../../include -split-input-file 2>&1 | FileCheck %s
 
 // CHECK: expected top-level declaration, such as a `Pattern`
 10
 
 // -----
 
 Pattern {
   // CHECK: expected `;` after statement

 
 Pattern {
   // CHECK: `Constraint`s applied via a variable constraint list must take a single input, but got 2
   let foo: MultiConstraint;
 }
 
 // -----
 
+#include "include/ops.td"
+
+Pattern {
+  // CHECK: unable to convert expression of type `Op<test.all_empty>` to the expected type of `Value` 
+  // CHECK: see the definition of `test.all_empty`, which was defined with zero results
+  let value: Value = op<test.all_empty>;
+  erase _: Op;
+}
+
+// -----
+
+#include "include/ops.td"
+
+Pattern {
+  // CHECK: unable to convert expression of type `Op<test.multiple_single_result>` to the expected type of `Value` 
+  // CHECK: see the definition of `test.multiple_single_result`, which was defined with at least 2 results
+  let value: Value = op<test.multiple_single_result>;
+  erase _: Op;
+}
+
+// -----
+
 //===----------------------------------------------------------------------===//
 // `replace`
 //===----------------------------------------------------------------------===//
 
 Pattern {
   // CHECK: expected `Op` expression
   replace attr<""> with attr<"">;
 }

mlir/tools/mlir-pdll/mlir-pdll.cpp

 //===- mlir-pdll.cpp - MLIR PDLL frontend -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Support/ToolUtilities.h"
 #include "mlir/Tools/PDLL/AST/Context.h"
 #include "mlir/Tools/PDLL/AST/Nodes.h"
 #include "mlir/Tools/PDLL/CodeGen/CPPGen.h"
 #include "mlir/Tools/PDLL/CodeGen/MLIRGen.h"
+#include "mlir/Tools/PDLL/ODS/Context.h"
 #include "mlir/Tools/PDLL/Parser/Parser.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace mlir;
 using namespace mlir::pdll;
 
 //===----------------------------------------------------------------------===//
 // main
 //===----------------------------------------------------------------------===//
 
 /// The desired output type.
 enum class OutputType {
   AST,
   MLIR,
   CPP,
 };
 
 static LogicalResult
 processBuffer(raw_ostream &os, std::unique_ptr<llvm::MemoryBuffer> chunkBuffer,
-              OutputType outputType, std::vector<std::string> &includeDirs) {
+              OutputType outputType, std::vector<std::string> &includeDirs,
+              bool dumpODS) {
   llvm::SourceMgr sourceMgr;
   sourceMgr.setIncludeDirs(includeDirs);
   sourceMgr.AddNewSourceBuffer(std::move(chunkBuffer), SMLoc());
 
-  ast::Context astContext;
+  ods::Context odsContext;
+  ast::Context astContext(odsContext);
   FailureOr<ast::Module *> module = parsePDLAST(astContext, sourceMgr);
   if (failed(module))
     return failure();
 
+  // Print out the ODS information if requested.
+  if (dumpODS)
+    odsContext.print(llvm::errs());
+
+  // Generate the output.
   if (outputType == OutputType::AST) {
     (*module)->print(os);
     return success();
   }
 
   MLIRContext mlirContext;
   OwningOpRef<ModuleOp> pdlModule =
       codegenPDLLToMLIR(&mlirContext, astContext, sourceMgr, **module);
int main(int argc, char **argv) {
   llvm::cl::opt<std::string> outputFilename(
       "o", llvm::cl::desc("Output filename"), llvm::cl::value_desc("filename"),
       llvm::cl::init("-"));
 
   llvm::cl::list<std::string> includeDirs(
       "I", llvm::cl::desc("Directory of include files"),
       llvm::cl::value_desc("directory"), llvm::cl::Prefix);
 
+  llvm::cl::opt<bool> dumpODS(
+      "dump-ods",
+      llvm::cl::desc(
+          "Print out the parsed ODS information from the input file"),
+      llvm::cl::init(false));
   llvm::cl::opt<bool> splitInputFile(
       "split-input-file",
       llvm::cl::desc("Split the input file into pieces and process each "
                      "chunk independently"),
       llvm::cl::init(false));
   llvm::cl::opt<enum OutputType> outputType(
       "x", llvm::cl::init(OutputType::AST),
       llvm::cl::desc("The type of output desired"),
if (!outputFile) {
     llvm::errs() << errorMessage << "\n";
     return 1;
   }
 
   // The split-input-file mode is a very specific mode that slices the file
   // up into small pieces and checks each independently.
   auto processFn = [&](std::unique_ptr<llvm::MemoryBuffer> chunkBuffer,
                        raw_ostream &os) {
-    return processBuffer(os, std::move(chunkBuffer), outputType, includeDirs);
+    return processBuffer(os, std::move(chunkBuffer), outputType, includeDirs,
+                         dumpODS);
   };
   if (splitInputFile) {
     if (failed(splitAndProcessBuffer(std::move(inputFile), processFn,
                                      outputFile->os())))
       return 1;
   } else if (failed(processFn(std::move(inputFile), outputFile->os()))) {
     return 1;
   }
   outputFile->keep();
   return 0;
 }