[mlir][PDL] Add a PDL Interpreter Dialect

[rriddle]

Summary

The PDL Interpreter dialect provides a lower level abstraction compared to the PDL dialect, and is targeted towards low level optimization and interpreter code generation. The dialect operations encapsulates low-level pattern match and rewrite "primitives", such as navigating the IR (Operation::getOperand), creating new operations (OpBuilder::create), etc. Many of the operations within this dialect also fuse branching control flow with some form of a predicate comparison operation. This type of fusion reduces the amount of work that an interpreter must do when executing.

An example of this representation is shown below:

mlir
// The following high level PDL pattern:
pdl.pattern : benefit(1) {
  %resultType = pdl.type
  %inputOperand = pdl.input
  %root, %results = pdl.operation "foo.op"(%inputOperand) -> %resultType
  pdl.rewrite(%root) {
    pdl.replace %root with (%inputOperand)
  }
}

// May be represented in the interpreter dialect as follows:
module {
  func @matcher(%arg0: !pdl.operation) {
    pdl_interp.check_operation_name of %arg0 is "foo.op" -> ^bb2, ^bb1
  ^bb1:
    pdl_interp.return
  ^bb2:
    pdl_interp.check_operand_count of %arg0 is 1 -> ^bb3, ^bb1
  ^bb3:
    pdl_interp.check_result_count of %arg0 is 1 -> ^bb4, ^bb1
  ^bb4:
    %0 = pdl_interp.get_operand 0 of %arg0
    pdl_interp.is_not_null %0 : !pdl.value -> ^bb5, ^bb1
  ^bb5:
    %1 = pdl_interp.get_result 0 of %arg0
    pdl_interp.is_not_null %1 : !pdl.value -> ^bb6, ^bb1
  ^bb6:
    pdl_interp.record_match @rewriters::@rewriter(%0, %arg0 : !pdl.value, !pdl.operation) : benefit(1), loc([%arg0]), root("foo.op") -> ^bb1
  }
  module @rewriters {
    func @rewriter(%arg0: !pdl.value, %arg1: !pdl.operation) {
      pdl_interp.replace %arg1 with(%arg0)
      pdl_interp.return
    }
  }
}

Depends On D84578

[rriddle]

Remove unnecessary interfaces

[stephenneuendorffer]

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

25

PDLInterpreter?

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

16

pdl_interpreter?

[rriddle]

Rebase

[mehdi_amini]

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

89

name in the description does not match the op name?

100

it isn't clear to me how are the constant parsed? What is the type of 42 for example?

Could you give an example of the "myConstraint" signature / impl?

127

It isn't clear from the description what kind of state the rewrite has access to, maybe explain a bit and refer the reader to pdl_interp.record_match ?

142

"equivalence" isn't super clear: is it more that straight equality?

300

Most of the ops above aren't annotated as "NoSideEffect", should they? Aren't all the "check" in scope for "NoSideEffect"?

533

Can you show the result on the sample? (same for the other get_*)

690

replaced->replace

715

Maybe we can do something else than "return"?
"finish"? "done"? "finalize"?

[rriddle]

Address comments

[rriddle]

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

100

It's an ArrayAttr, 42 is an IntegerAttr which has a default type of i64.

Could you give an example of the "myConstraint" signature / impl?

Waiting for the bytecode before adding signature examples, because they are directly related.

715

Went with finalize.

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

16

I considered it, but I don't think spelling it out completely improves the readability as much as it hurts it by making everything longer.

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterp.h

+//===- PDLInterp.h - PDL Interpreter 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the interpreter dialect for the PDL pattern descriptor
+// language.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
+#define MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
+
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/InferTypeOpInterface.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+
+namespace mlir {
+namespace pdl_interp {
+//===----------------------------------------------------------------------===//
+// PDLInterp Dialect
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/PDLInterp/IR/PDLInterpDialect.h.inc"
+
+//===----------------------------------------------------------------------===//
+// PDLInterp Dialect Operations
+//===----------------------------------------------------------------------===//
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.h.inc"
+
+} // end namespace pdl_interp
+} // end namespace mlir
+
+#endif // MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

+//===- PDLInterpOps.td - Pattern Interpreter Dialect -------*- tablegen -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the PDL interpreter dialect ops.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS
+#define MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS
+
+include "mlir/Dialect/PDL/IR/PDLBase.td"
+include "mlir/Interfaces/SideEffectInterfaces.td"
+
+//===----------------------------------------------------------------------===//
+// PDLInterp Dialect
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_Dialect : Dialect {
+  let summary = "Interpreted pattern execution dialect";
+  let description = [{
+    The PDL Interpreter dialect provides a lower level abstraction compared to
+    the PDL dialect, and is targeted towards low level optimization and
+    interpreter code generation. The dialect operations encapsulates
+    low-level pattern match and rewrite "primitives", such as navigating the
+    IR (Operation::getOperand), creating new operations (OpBuilder::create),
+    etc. Many of the operations within this dialect also fuse branching control
+    flow with some form of a predicate comparison operation. This type of fusion
+    reduces the amount of work that an interpreter must do when executing.
+  }];
+
+  let name = "pdl_interp";
+  let cppNamespace = "mlir::pdl_interp";
+}
+
+//===----------------------------------------------------------------------===//
+// PDLInterp Operations
+//===----------------------------------------------------------------------===//
+
+// Generic interpreter operation.
+class PDLInterp_Op<string mnemonic, list<OpTrait> traits = []> :
+    Op<PDLInterp_Dialect, mnemonic, traits>;
+
+//===----------------------------------------------------------------------===//
+// PDLInterp_PredicateOp
+
+// Check operations evaluate a predicate on a positional value and then
+// conditionally branch on the result.
+class PDLInterp_PredicateOp<string mnemonic, list<OpTrait> traits = []> :
+    PDLInterp_Op<mnemonic, !listconcat([Terminator], traits)> {
+  let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
+}
+
+//===----------------------------------------------------------------------===//
+// PDLInterp_SwitchOp
+
+// Switch operations evaluate a predicate on a positional value and then
+// conditionally branch on the result.
+class PDLInterp_SwitchOp<string mnemonic, list<OpTrait> traits = []> :
+    PDLInterp_Op<mnemonic, !listconcat([Terminator], traits)> {
+  let successors = (successor AnySuccessor:$defaultDest,
+                              VariadicSuccessor<AnySuccessor>:$cases);
+
+  let verifier = [{
+    // Verify that the number of case destinations matches the number of case
+    // values.
+    size_t numDests = cases().size();
+    size_t numValues = caseValues().size();
+    if (numDests != numValues) {
+      return emitOpError("expected number of cases to match the number of case "
+                         "values, got ")
+          << numDests << " but expected " << numValues;
+    }
+    return success();
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::ApplyConstraintOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_ApplyConstraintOp : PDLInterp_PredicateOp<"apply_constraint"> {
+  let summary = "Apply a constraint to a set of positional values";
+  let description = [{
+    `pdl_interp.apply_generic_constraint` operations apply a generic constraint,
+    that has been registered with the interpreter, with a given set of
+    positional values. The constraint may have any number of constant
+    parameters. On success, this operation branches to the true destination,
+    otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    // Apply `myConstraint` to the entities defined by `input`, `attr`, and
+    // `op`.
+    pdl_interp.apply_constraint "myConstraint"[42, "abc", i32](%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation)
+    ```
+  }];
+
+  let arguments = (ins Variadic<PDL_PositionalValue>:$values,
+                       StrAttr:$name,
+                       ArrayAttr:$params);
+  let assemblyFormat = [{
+    $name $params `(` $values `:` type($values) `)` attr-dict `->` successors
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::ApplyRewriteOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_ApplyRewriteOp : PDLInterp_Op<"apply_rewrite"> {
+  let summary = "Invoke and apply an externally registered rewrite method";
+  let description = [{
+    `pdl_interp.apply_rewrite` operations invoke an external rewriter that has
+    been registered with the interpreter to perform the rewrite after a
+    successful match.
+
+    Example:
+
+    ```mlir
+    pdl_interp.apply_rewrite "rewriter"
+    ```
+  }];
+  let arguments = (ins StrAttr:$name);
+  let assemblyFormat = "$name attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::AreEqualOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_AreEqualOp : PDLInterp_PredicateOp<"are_equal",
+                                                 [SameTypeOperands]> {
+  let summary = "Check if two positional values are equivalent";
+  let description = [{
+    `pdl_interp.are_equal` operations compare two positional values for
+    equivalence. On success, this operation branches to the true destination,
+    otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.are_equal %result1, %result2 : !pdl.value -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_PositionalValue:$lhs,
+                       PDL_PositionalValue:$rhs);
+  let assemblyFormat = "operands `:` type($lhs) attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::BranchOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_BranchOp : PDLInterp_Op<"branch", [Terminator]> {
+  let summary = "General branch operation";
+  let description = [{
+    `pdl_interp.branch` operations expose general branch functionality to the
+    interpreter, and are generally used to branch from one pattern match
+    sequence to another.
+
+    Example:
+
+    ```mlir
+    pdl_interp.branch ^dest
+    ```
+  }];
+
+  let successors = (successor AnySuccessor:$dest);
+  let assemblyFormat = "$dest attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckAttributeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckAttributeOp : PDLInterp_PredicateOp<"check_attribute"> {
+  let summary = "Check the value of an `Attribute`";
+  let description = [{
+    `pdl_interp.check_attribute` operations compare the value of a given
+    attribute with a constant value. On success, this operation branches to the
+    true destination, otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_attribute %attr is 10 -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Attribute:$attribute, AnyAttr:$constantValue);
+  let assemblyFormat = [{
+    $attribute `is` $constantValue attr-dict `->` successors
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckOperandCountOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckOperandCountOp
+    : PDLInterp_PredicateOp<"check_operand_count"> {
+  let summary = "Check the number of operands of an `Operation`";
+  let description = [{
+    `pdl_interp.check_operand_count` operations compare the number of operands
+    of a given operation value with a constant. On success, this operation
+    branches to the true destination, otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_operand_count of %op is 2 -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       Confined<I32Attr, [IntNonNegative]>:$count);
+  let assemblyFormat = "`of` $operation `is` $count attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckOperationNameOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckOperationNameOp
+    : PDLInterp_PredicateOp<"check_operation_name"> {
+  let summary = "Check the OperationName of an `Operation`";
+  let description = [{
+    `pdl_interp.check_operation_name` operations compare the name of a given
+    operation with a known name. On success, this operation branches to the true
+    destination, otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_operation_name of %op is "foo.op" -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation, StrAttr:$name);
+  let assemblyFormat = "`of` $operation `is` $name attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckResultCountOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckResultCountOp : PDLInterp_PredicateOp<"check_result_count"> {
+  let summary = "Check the number of results of an `Operation`";
+  let description = [{
+    `pdl_interp.check_result_count` operations compare the number of results
+    of a given operation value with a constant. On success, this operation
+    branches to the true destination, otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_result_count of %op is 0 -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                   Confined<I32Attr, [IntNonNegative]>:$count);
+  let assemblyFormat = "`of` $operation `is` $count attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckTypeOp : PDLInterp_PredicateOp<"check_type"> {
+  let summary = "Compare a type to a known value";
+  let description = [{
+    `pdl_interp.check_type` operations compare a type with a statically known
+    type. On success, this operation branches to the true destination, otherwise
+    the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_type %type is 0 -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Type:$value, TypeAttr:$type);
+  let assemblyFormat = "$value `is` $type attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateAttributeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CreateAttributeOp
+    : PDLInterp_Op<"create_attribute", [NoSideEffect]> {
+  let summary = "Create an interpreter handle to a constant `Attribute`";
+  let description = [{
+    `pdl_interp.create_attribute` operations generate a handle within the
+    interpreter for a specific constant attribute value.
+
+    Example:
+
+    ```mlir
+    pdl_interp.create_attribute 10 : i64
+    ```
+  }];
+
+  let arguments = (ins AnyAttr:$value);
+  let results = (outs PDL_Attribute:$attribute);
+  let assemblyFormat = "$value attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, "
+              "Attribute value", [{
+    build(builder, state, builder.getType<pdl::AttributeType>(), value);
+  }]>];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateNativeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CreateNativeOp : PDLInterp_Op<"create_native"> {
+  let summary = "Call a native creation method to construct an `Attribute`, "
+                "`Operation`, `Type`, or `Value`";
+  let description = [{
+    `pdl_interp.create_native` operations invoke a native C++ function, that has
+    been registered externally with the consumer of PDL, to create an
+    `Attribute`, `Operation`, `Type`, or `Value`. The native function must
+    produce a value of the specified return type, and may accept any number of
+    positional arguments and constant attribute parameters.
+
+    Example:
+
+    ```mlir
+    %ret = pdl_interp.create_native "myNativeFunc"[42, "gt"](%arg0, %arg1) : !pdl.attribute
+    ```
+  }];
+
+  let arguments = (ins StrAttr:$name, Variadic<PDL_PositionalValue>:$arguments,
+                       ArrayAttr:$constantParams);
+  let results = (outs PDL_PositionalValue:$result);
+  let assemblyFormat = [{
+    $name $constantParams (`(` $arguments^ `:` type($arguments) `)`)?
+    `:` type($result) attr-dict
+  }];
+  let verifier = ?;
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateOperationOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CreateOperationOp
+    : PDLInterp_Op<"create_operation", [AttrSizedOperandSegments]> {
+  let summary = "Create an instance of a specific `Operation`";
+  let description = [{
+    `pdl_interp.create_operation` operations create an `Operation` instance with
+    the specified attributes, operands, and result types.
+
+    Example:
+
+    ```mlir
+    // Create an instance of a `foo.op` operation.
+    %op = pdl_interp.create_operation "foo.op"(%arg0) {"attrA" = %attr0} -> %type, %type
+    ```
+  }];
+
+  let arguments = (ins StrAttr:$name,
+                       Variadic<PDL_Value>:$operands,
+                       Variadic<PDL_Attribute>:$attributes,
+                       StrArrayAttr:$attributeNames,
+                       Variadic<PDL_Type>:$types);
+  let results = (outs PDL_Operation:$operation);
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, StringRef name, "
+              "ValueRange types, ValueRange operands, ValueRange attributes, "
+              "ArrayAttr attributeNames", [{
+    build(builder, state, builder.getType<pdl::OperationType>(), name,
+          operands, attributes, attributeNames, types);
+  }]>];
+  let parser = [{ return ::parseCreateOperationOp(parser, result); }];
+  let printer = [{ ::print(p, *this); }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CreateTypeOp : PDLInterp_Op<"create_type", [NoSideEffect]> {
+  let summary = "Create an interpreter handle to a constant `Type`";
+  let description = [{
+    `pdl_interp.create_type` operations generate a handle within the interpreter
+    for a specific constant type value.
+
+    Example:
+
+    ```mlir
+    pdl_interp.create_type i64
+    ```
+  }];
+
+  let arguments = (ins TypeAttr:$value);
+  let results = (outs PDL_Type:$result);
+  let assemblyFormat = "$value attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, TypeAttr type", [{
+      build(builder, state, builder.getType<pdl::TypeType>(), type);
+    }]>
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::EraseOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_EraseOp : PDLInterp_Op<"erase"> {
+  let summary = "Mark an operation as `erased`";
+  let description = [{
+    `pdl.erase` operations are used to specify that an operation should be
+    marked as erased. The semantics of this operation correspond with the
+    `eraseOp` method on a `PatternRewriter`.
+
+    Example:
+
+    ```mlir
+    pdl_interp.erase %root
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation);
+  let assemblyFormat = "$operation attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetAttributeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetAttributeOp : PDLInterp_Op<"get_attribute", [NoSideEffect]> {
+  let summary = "Get a specified attribute value from an `Operation`";
+  let description = [{
+    `pdl_interp.get_attribute` operations try to get a specific attribute from
+    an operation. If the operation does not have that attribute, a null value is
+    returned.
+
+    Example:
+
+    ```mlir
+    pdl_interp.get_attribute "attr" of %op
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                   StrAttr:$name);
+  let results = (outs PDL_Attribute:$attribute);
+  let assemblyFormat = "$name `of` $operation attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetAttributeTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetAttributeTypeOp
+    : PDLInterp_Op<"get_attribute_type", [NoSideEffect]> {
+  let summary = "Get the result type of a specified `Attribute`";
+  let description = [{
+    `pdl_interp.get_attribute_type` operations get the resulting type of a
+    specific attribute.
+
+    Example:
+
+    ```mlir
+    pdl_interp.get_attribute_type of %attr
+    ```
+  }];
+
+  let arguments = (ins PDL_Attribute:$value);
+  let results = (outs PDL_Type:$result);
+  let assemblyFormat = "`of` $value attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value value", [{
+      build(builder, state, builder.getType<pdl::TypeType>(), value);
+    }]>
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetDefiningOpOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetDefiningOpOp
+    : PDLInterp_Op<"get_defining_op", [NoSideEffect]> {
+  let summary = "Get the defining operation of a `Value`";
+  let description = [{
+    `pdl_interp.get_defining_op` operations try to get the defining operation
+    of a specific value. If the value is not an operation result, null is
+    returned.
+
+    Example:
+
+    ```mlir
+    pdl_interp.get_defining_op of %value
+    ```
+  }];
+
+  let arguments = (ins PDL_Value:$value);
+  let results = (outs PDL_Operation:$operation);
+  let assemblyFormat = "`of` $value attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetOperandOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetOperandOp : PDLInterp_Op<"get_operand", [NoSideEffect]> {
+  let summary = "Get a specified operand from an `Operation`";
+  let description = [{
+    `pdl_interp.get_operand` operations try to get a specific operand from an
+    operation If the operation does not have an operand for the given index, a
+    null value is returned.
+
+    Example:
+
+    ```mlir
+    pdl_interp.get_operand 1 of %op
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       Confined<I32Attr, [IntNonNegative]>:$index);
+  let results = (outs PDL_Value:$value);
+  let assemblyFormat = "$index `of` $operation attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetResultOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetResultOp : PDLInterp_Op<"get_result", [NoSideEffect]> {
+  let summary = "Get a specified result from an `Operation`";
+  let description = [{
+    `pdl_interp.get_result` operations try to get a specific result from an
+    operation. If the operation does not have a result for the given index, a
+    null value is returned.
+
+    Example:
+
+    ```mlir
+    pdl_interp.get_result 1 of %op
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       Confined<I32Attr, [IntNonNegative]>:$index);
+  let results = (outs PDL_Value:$value);
+  let assemblyFormat = "$index `of` $operation attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetValueTypeOp
+//===----------------------------------------------------------------------===//
+
+// Get a type from the root operation, held in the rewriter context.
+def PDLInterp_GetValueTypeOp : PDLInterp_Op<"get_value_type", [NoSideEffect]> {
+  let summary = "Get the result type of a specified `Value`";
+  let description = [{
+    `pdl_interp.get_value_type` operations get the resulting type of a specific
+    value.
+
+    Example:
+
+    ```mlir
+    pdl_interp.get_value_type of %value
+    ```
+  }];
+
+  let arguments = (ins PDL_Value:$value);
+  let results = (outs PDL_Type:$result);
+  let assemblyFormat = "`of` $value attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value value", [{
+      build(builder, state, builder.getType<pdl::TypeType>(), value);
+    }]>
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::InferredTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_InferredTypeOp : PDLInterp_Op<"inferred_type"> {
+  let summary = "Generate a handle to a Type that is \"inferred\"";
+  let description = [{
+    `pdl_interp.inferred_type` operations generate a handle to a type that
+    should be inferred. This signals to other operations, such as
+    `pdl_interp.create_operation`, that this type should be inferred.
+
+    Example:
+
+    ```mlir
+    pdl_interp.inferred_type
+    ```
+  }];
+  let results = (outs PDL_Type:$type);
+  let assemblyFormat = "attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state", [{
+      build(builder, state, builder.getType<pdl::TypeType>());
+    }]>,
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::IsNotNullOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_IsNotNullOp : PDLInterp_PredicateOp<"is_not_null"> {
+  let summary = "Check if a positional value is non-null";
+  let description = [{
+    `pdl_interp.is_not_null` operations check that a positional value exists. On
+    success, this operation branches to the true destination. Otherwise, the
+    false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.is_not_null %value : !pdl.value -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_PositionalValue:$value);
+  let assemblyFormat = "$value `:` type($value) attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::RecordMatchOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_RecordMatchOp
+    : PDLInterp_Op<"record_match", [AttrSizedOperandSegments, Terminator]> {
+  let summary = "Record the metadata for a successful pattern match";
+  let description = [{
+    `pdl_interp.record_match` operations record a successful pattern match with
+    the interpreter and branch to the next part of the matcher. The metadata
+    recorded by these operations correspond to a specific `pdl.pattern`, as well
+    as what values were used during that match that should be propagated to the
+    rewriter.
+
+    Example:
+
+    ```mlir
+    pdl_interp.record_match @rewriters::myRewriter(%root : !pdl.operation) : benefit(1), loc([%root, %op1]), root("foo.op") -> ^nextDest
+    ```
+  }];
+
+  let arguments = (ins Variadic<PDL_PositionalValue>:$inputs,
+                       Variadic<PDL_Operation>:$matchedOps,
+                       SymbolRefAttr:$rewriter,
+                       OptionalAttr<StrAttr>:$rootKind,
+                       OptionalAttr<StrArrayAttr>:$generatedOps,
+                       OptionalAttr<Confined<I16Attr,
+                                             [IntNonNegative]>>:$benefit);
+  let successors = (successor AnySuccessor:$dest);
+  let assemblyFormat = [{
+    $rewriter (`(` $inputs^ `:` type($inputs) `)`)? `:`
+    `benefit` `(` $benefit `)` `,`
+    (`generatedOps` `(` $generatedOps^ `)` `,`)?
+    `loc` `(` `[` $matchedOps `]` `)`
+    (`,` `root` `(` $rootKind^ `)`)? attr-dict `->` $dest
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::ReplaceOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_ReplaceOp : PDLInterp_Op<"replace"> {
+  let summary = "Mark an operation as `replaced`";
+  let description = [{
+    `pdl_interp.replaced` operations are used to specify that an operation
+    should be marked as replaced. The semantics of this operation correspond
+    with the `replaceOp` method on a `PatternRewriter`. The set of replacement
+    values must match the number of results specified by the operation.
+
+    Example:
+
+    ```mlir
+    // Replace root node with 2 values:
+    pdl_interp.replace %root with (%val0, %val1)
+    ```
+  }];
+  let arguments = (ins PDL_Operation:$operation,
+                       Variadic<PDL_Value>:$replValues);
+  let assemblyFormat = "$operation `with` `(` $replValues `)` attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::ReturnOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_ReturnOp : PDLInterp_Op<"return", [Terminator]> {
+  let summary = "Terminate a pattern match or rewrite sequence";
+  let description = [{
+    `pdl_interp.return` is used to denote the termination of a match or rewrite
+    sequence.
+
+    Example:
+
+    ```mlir
+    pdl_interp.return
+    ```
+  }];
+  let assemblyFormat = "attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type"> {
+  let summary = "Switch on a `Type` value";
+  let description = [{
+    `pdl_interp.switch_type` operations compare a type with a set of statically
+    known types. If the value matches one of the provided case values the
+    destination for that case value is taken, otherwise the default destination
+    is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_type %type to [i32, i64] -> ^i32Dest, ^i64Dest, ^defaultDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Type:$value, TypeArrayAttr:$caseValues);
+  let assemblyFormat = [{
+    $value `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value edge, "
+              "TypeRange types, Block *defaultDest, ArrayRef<Block *> dests", [{
+      build(builder, state, edge, builder.getTypeArrayAttr(types), defaultDest,
+            dests);
+    }]>,
+  ];
+
+  let extraClassDeclaration = [{
+    auto getCaseTypes() { return caseValues().getAsValueRange<TypeAttr>(); }
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchAttributeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchAttributeOp : PDLInterp_SwitchOp<"switch_attribute"> {
+  let summary = "Switch on the value of an `Attribute`";
+  let description = [{
+    `pdl_interp.switch_attribute` operations compare the value of a given
+    attribute with a set of constant attributes. If the value matches one of the
+    provided case values the destination for that case value is taken, otherwise
+    the default destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_attribute %attr to [10, true] -> ^10Dest, ^trueDest, ^defaultDest
+    ```
+  }];
+  let arguments = (ins PDL_Attribute:$attribute, ArrayAttr:$caseValues);
+  let assemblyFormat = [{
+    $attribute `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value attribute,"
+              "ArrayRef<Attribute> caseValues,"
+              "Block *defaultDest, ArrayRef<Block *> dests", [{
+    build(builder, state, attribute, builder.getArrayAttr(caseValues),
+          defaultDest, dests);
+  }]>];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchOperandCountOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchOperandCountOp
+    : PDLInterp_SwitchOp<"switch_operand_count"> {
+  let summary = "Switch on the operand count of an `Operation`";
+  let description = [{
+    `pdl_interp.switch_operand_count` operations compare the operand count of a
+    given operation with a set of potential counts. If the value matches one of
+    the provided case values the destination for that case value is taken,
+    otherwise the default destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_operand_count of %op to [10, 2] -> ^10Dest, ^2Dest, ^defaultDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
+  let assemblyFormat = [{
+    `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
+              "ArrayRef<int32_t> counts, Block *defaultDest, "
+              "ArrayRef<Block *> dests", [{
+    build(builder, state, operation, builder.getI32VectorAttr(counts),
+          defaultDest, dests);
+  }]>];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchOperationNameOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchOperationNameOp
+    : PDLInterp_SwitchOp<"switch_operation_name"> {
+  let summary = "Switch on the OperationName of an `Operation`";
+  let description = [{
+    `pdl_interp.switch_operation_name` operations compare the name of a given
+    operation with a set of known names. If the value matches one of the
+    provided case values the destination for that case value is taken, otherwise
+    the default destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_operation_name of %op to ["foo.op", "bar.op"] -> ^fooDest, ^barDest, ^defaultDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       StrArrayAttr:$caseValues);
+  let assemblyFormat = [{
+    `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
+              "ArrayRef<OperationName> names, "
+              "Block *defaultDest, ArrayRef<Block *> dests", [{
+      auto stringNames = llvm::to_vector<8>(llvm::map_range(names,
+          [](OperationName name) { return name.getStringRef(); }));
+      build(builder, state, operation, builder.getStrArrayAttr(stringNames),
+            defaultDest, dests);
+    }]>,
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchResultCountOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchResultCountOp : PDLInterp_SwitchOp<"switch_result_count"> {
+  let summary = "Switch on the result count of an `Operation`";
+  let description = [{
+    `pdl_interp.switch_result_count` operations compare the result count of a
+    given operation with a set of potential counts. If the value matches one of
+    the provided case values the destination for that case value is taken,
+    otherwise the default destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_result_count of %op to [0, 2] -> ^0Dest, ^2Dest, ^defaultDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
+  let assemblyFormat = [{
+    `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
+              "ArrayRef<int32_t> counts, Block *defaultDest, "
+              "ArrayRef<Block *> dests", [{
+    build(builder, state, operation, builder.getI32VectorAttr(counts),
+          defaultDest, dests);
+  }]>];
+}
+
+#endif // MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS

mlir/include/mlir/IR/Attributes.h

public:
     explicit attr_value_iterator(ArrayAttr::iterator it)
         : llvm::mapped_iterator<ArrayAttr::iterator, AttrTy (*)(Attribute)>(
               it, [](Attribute attr) { return attr.cast<AttrTy>(); }) {}
     AttrTy operator*() const { return (*this->I).template cast<AttrTy>(); }
   };
 
 public:
   template <typename AttrTy>
-  llvm::iterator_range<attr_value_iterator<AttrTy>> getAsRange() {
+  iterator_range<attr_value_iterator<AttrTy>> getAsRange() {
     return llvm::make_range(attr_value_iterator<AttrTy>(begin()),
                             attr_value_iterator<AttrTy>(end()));
   }
-  template <typename AttrTy, typename UnderlyingTy>
-  auto getAsRange() {
+  template <typename AttrTy, typename UnderlyingTy = typename AttrTy::ValueType>
+  auto getAsValueRange() {
     return llvm::map_range(getAsRange<AttrTy>(), [](AttrTy attr) {
       return static_cast<UnderlyingTy>(attr.getValue());
     });
   }
 };
 
 //===----------------------------------------------------------------------===//
 // DictionaryAttr
public:
   template <typename T> iterator_range<T> getValues() const;
 
   /// Return if the given 'index' refers to a valid element in this attribute.
   bool isValidIndex(ArrayRef<uint64_t> index) const;
 
   /// Returns the number of elements held by this attribute.
   int64_t getNumElements() const;
 
+  /// Returns the number of elements held by this attribute.
+  int64_t size() const { return getNumElements(); }
+
   /// Generates a new ElementsAttr by mapping each int value to a new
   /// underlying APInt. The new values can represent either an integer or float.
   /// This ElementsAttr should contain integers.
   ElementsAttr mapValues(Type newElementType,
                          function_ref<APInt(const APInt &)> mapping) const;
 
   /// Generates a new ElementsAttr by mapping each float value to a new
   /// underlying APInt. The new values can represent either an integer or float.

mlir/include/mlir/IR/Builders.h

public:
   ArrayAttr getAffineMapArrayAttr(ArrayRef<AffineMap> values);
   ArrayAttr getBoolArrayAttr(ArrayRef<bool> values);
   ArrayAttr getI32ArrayAttr(ArrayRef<int32_t> values);
   ArrayAttr getI64ArrayAttr(ArrayRef<int64_t> values);
   ArrayAttr getIndexArrayAttr(ArrayRef<int64_t> values);
   ArrayAttr getF32ArrayAttr(ArrayRef<float> values);
   ArrayAttr getF64ArrayAttr(ArrayRef<double> values);
   ArrayAttr getStrArrayAttr(ArrayRef<StringRef> values);
+  ArrayAttr getTypeArrayAttr(TypeRange values);
 
   // Affine expressions and affine maps.
   AffineExpr getAffineDimExpr(unsigned position);
   AffineExpr getAffineSymbolExpr(unsigned position);
   AffineExpr getAffineConstantExpr(int64_t constant);
 
   // Special cases of affine maps and integer sets
   /// Returns a zero result affine map with no dimensions or symbols: () -> ().

mlir/include/mlir/InitAllDialects.h

 #include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/Dialect/Quant/QuantOps.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/SDBM/SDBMDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/Shape/IR/Shape.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/Dialect.h"
 
 namespace mlir {
 
 // This function should be called before creating any MLIRContext if one expect
 // all the possible dialects to be made available to the context automatically.
 inline void registerAllDialects() {
   static bool init_once = []() {
     registerDialect<acc::OpenACCDialect>();
     registerDialect<AffineDialect>();
     registerDialect<avx512::AVX512Dialect>();
     registerDialect<gpu::GPUDialect>();
     registerDialect<LLVM::LLVMAVX512Dialect>();
     registerDialect<LLVM::LLVMDialect>();
     registerDialect<linalg::LinalgDialect>();
     registerDialect<pdl::PDLDialect>();
+    registerDialect<pdl_interp::PDLInterpDialect>();
     registerDialect<scf::SCFDialect>();
     registerDialect<omp::OpenMPDialect>();
     registerDialect<quant::QuantizationDialect>();
     registerDialect<spirv::SPIRVDialect>();
     registerDialect<StandardOpsDialect>();
     registerDialect<vector::VectorDialect>();
     registerDialect<NVVM::NVVMDialect>();
     registerDialect<ROCDL::ROCDLDialect>();

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

static LogicalResult isContraction(Operation *op) {
   if (isa<linalg::BatchMatmulOp, linalg::MatmulOp, linalg::MatvecOp,
           linalg::DotOp>(op))
     return success();
 
   auto genericOp = dyn_cast<linalg::GenericOp>(op);
   if (!genericOp)
     return failure();
 
-  auto mapRange =
-      genericOp.indexing_maps().getAsRange<AffineMapAttr, AffineMap>();
-
+  auto mapRange = genericOp.indexing_maps().getAsValueRange<AffineMapAttr>();
   return success(
       genericOp.getNumInputs() == 2 && genericOp.getNumOutputs() == 1 &&
       llvm::all_of(mapRange,
                    [](AffineMap m) { return m.isProjectedPermutation(); }) &&
       hasMultiplyAddBody(genericOp.region()));
 }
 
 LogicalResult mlir::linalg::vectorizeLinalgOpPrecondition(Operation *op) {

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

+//===- PDLInterp.cpp - PDL Interpreter 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
+#include "mlir/Dialect/PDL/IR/PDLTypes.h"
+#include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/StandardTypes.h"
+
+using namespace mlir;
+using namespace mlir::pdl_interp;
+
+//===----------------------------------------------------------------------===//
+// PDLInterp Dialect
+//===----------------------------------------------------------------------===//
+
+void PDLInterpDialect::initialize() {
+  addOperations<
+#define GET_OP_LIST
+#include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.cpp.inc"
+      >();
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateOperationOp
+//===----------------------------------------------------------------------===//
+
+static ParseResult parseCreateOperationOp(OpAsmParser &p,
+                                          OperationState &state) {
+  if (p.parseOptionalAttrDict(state.attributes))
+    return failure();
+  Builder &builder = p.getBuilder();
+
+  // Parse the operation name.
+  StringAttr opName;
+  if (p.parseAttribute(opName, "name", state.attributes))
+    return failure();
+
+  // Parse the operands.
+  SmallVector<OpAsmParser::OperandType, 4> operands;
+  if (p.parseLParen() || p.parseOperandList(operands) || p.parseRParen() ||
+      p.resolveOperands(operands, builder.getType<pdl::ValueType>(),
+                        state.operands))
+    return failure();
+
+  // Parse the attributes.
+  SmallVector<Attribute, 4> attrNames;
+  if (succeeded(p.parseOptionalLBrace())) {
+    SmallVector<OpAsmParser::OperandType, 4> attrOps;
+    do {
+      StringAttr nameAttr;
+      OpAsmParser::OperandType operand;
+      if (p.parseAttribute(nameAttr) || p.parseEqual() ||
+          p.parseOperand(operand))
+        return failure();
+      attrNames.push_back(nameAttr);
+      attrOps.push_back(operand);
+    } while (succeeded(p.parseOptionalComma()));
+
+    if (p.parseRBrace() ||
+        p.resolveOperands(attrOps, builder.getType<pdl::AttributeType>(),
+                          state.operands))
+      return failure();
+  }
+  state.addAttribute("attributeNames", builder.getArrayAttr(attrNames));
+  state.addTypes(builder.getType<pdl::OperationType>());
+
+  // Parse the result types.
+  SmallVector<OpAsmParser::OperandType, 4> opResultTypes;
+  if (p.parseArrow())
+    return failure();
+  if (succeeded(p.parseOptionalLParen())) {
+    if (p.parseRParen())
+      return failure();
+  } else if (p.parseOperandList(opResultTypes) ||
+             p.resolveOperands(opResultTypes, builder.getType<pdl::TypeType>(),
+                               state.operands)) {
+    return failure();
+  }
+
+  int32_t operandSegmentSizes[] = {static_cast<int32_t>(operands.size()),
+                                   static_cast<int32_t>(attrNames.size()),
+                                   static_cast<int32_t>(opResultTypes.size())};
+  state.addAttribute("operand_segment_sizes",
+                     builder.getI32VectorAttr(operandSegmentSizes));
+  return success();
+}
+
+static void print(OpAsmPrinter &p, CreateOperationOp op) {
+  p << "pdl_interp.create_operation ";
+  p.printOptionalAttrDict(op.getAttrs(),
+                          {"attributeNames", "name", "operand_segment_sizes"});
+  p << '"' << op.name() << "\"(" << op.operands() << ')';
+
+  // Emit the optional attributes.
+  ArrayAttr attrNames = op.attributeNames();
+  if (!attrNames.empty()) {
+    Operation::operand_range attrArgs = op.attributes();
+    p << " {";
+    interleaveComma(llvm::seq<int>(0, attrNames.size()), p,
+                    [&](int i) { p << attrNames[i] << " = " << attrArgs[i]; });
+    p << '}';
+  }
+
+  // Print the result type constraints of the operation.
+  auto types = op.types();
+  if (types.empty())
+    p << " -> ()";
+  else
+    p << " -> " << op.types();
+}
+
+//===----------------------------------------------------------------------===//
+// TableGen Auto-Generated Op and Interface Definitions
+//===----------------------------------------------------------------------===//
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.cpp.inc"

mlir/lib/IR/Builders.cpp

 }
 
 ArrayAttr Builder::getStrArrayAttr(ArrayRef<StringRef> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [this](StringRef v) -> Attribute { return getStringAttr(v); }));
   return getArrayAttr(attrs);
 }
 
+ArrayAttr Builder::getTypeArrayAttr(TypeRange values) {
+  auto attrs = llvm::to_vector<8>(llvm::map_range(
+      values, [this](Type v) -> Attribute { return TypeAttr::get(v); }));
+  return getArrayAttr(attrs);
+}
+
 ArrayAttr Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [](AffineMap v) -> Attribute { return AffineMapAttr::get(v); }));
   return getArrayAttr(attrs);
 }
 
 Attribute Builder::getZeroAttr(Type type) {
   if (type.isa<FloatType>())

mlir/test/Dialect/PDLInterp/ops.mlir

+// RUN: mlir-opt -split-input-file %s | mlir-opt
+// Verify the printed output can be parsed.
+// RUN: mlir-opt %s | mlir-opt
+// Verify the generic form can be parsed.
+// RUN: mlir-opt -mlir-print-op-generic %s | mlir-opt
+
+// -----
+
+func @operations(%attribute: !pdl.attribute,
+                 %input: !pdl.value,
+                 %type: !pdl.type) {
+  // attributes, operands, and results
+  %op0 = pdl_interp.create_operation "foo.op"(%input) {"attr" = %attribute} -> %type
+
+  // attributes, and results
+  %op1 = pdl_interp.create_operation "foo.op"() {"attr" = %attribute} -> %type
+
+  // attributes
+  %op2 = pdl_interp.create_operation "foo.op"() {"attr" = %attribute, "attr1" = %attribute} -> ()
+
+  // operands, and results
+  %op3 = pdl_interp.create_operation "foo.op"(%input) -> %type
+
+  pdl_interp.return
+}

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 bool LiteralElement::isValidLiteral(StringRef value) {
   if (value.empty())
     return false;
   char front = value.front();
 
   // If there is only one character, this must either be punctuation or a
   // single character bare identifier.
   if (value.size() == 1)
-    return isalpha(front) || StringRef("_:,=<>()[]?").contains(front);
+    return isalpha(front) || StringRef("_:,=<>()[]{}?").contains(front);
 
   // Check the punctuation that are larger than a single character.
   if (value == "->")
     return true;
 
   // Otherwise, this must be an identifier.
   if (!isalpha(front) && front != '_')
     return false;
static void genLiteralParser(StringRef value, OpMethodBody &body) {
   }
   body << (StringRef)llvm::StringSwitch<StringRef>(value)
               .Case("->", "Arrow()")
               .Case(":", "Colon()")
               .Case(",", "Comma()")
               .Case("=", "Equal()")
               .Case("<", "Less()")
               .Case(">", "Greater()")
+              .Case("{", "LBrace()")
+              .Case("}", "RBrace()")
               .Case("(", "LParen()")
               .Case(")", "RParen()")
               .Case("[", "LSquare()")
               .Case("]", "RSquare()")
               .Case("?", "Question()");
 }
 
 /// Generate the storage code required for parsing the given element.