[mlir][pdl] Remove CreateNativeOp in favor of a more general ApplyNativeRewriteOp.

[rriddle]

Summary

This has a numerous amount of benefits, given the overly clunky nature of CreateNativeOp:

• Users can now call into arbitrary rewrite functions from inside of PDL, allowing for more natural interleaving of PDL/C++ and enabling for more of the pattern to be in PDL.
• Removes the need for an additional set of C++ functions/registry/etc. The new ApplyNativeRewriteOp will use the same PDLRewriteFunction as the existing RewriteOp. This reduces the API surface area exposed to users.

This revision also introduces a new PDLResultList class. This class is used to provide results of native rewrite functions back to PDL. We introduce a new class instead of using a SmallVector to simplify the work necessary for variadics, given that ranges will require some changes to the structure of PDLValue.

Depends On D95719

[jpienaar]

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

89

Could you show the C++ side here too?

mlir/lib/Rewrite/ByteCode.cpp

1339–1342

Ooc why does the executor not use ref for first arg?

[rriddle]

rebase

[rriddle]

mlir/lib/Rewrite/ByteCode.cpp

1339–1342

For me it's more of conventional, i.e. it's a buffer of commands so it feels weird to pass a reference to the first value. I generally try to err on the side of "I pass this value in the way I expect to use it", which in this case is always as a buffer.

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

 class PDL_Op<string mnemonic, list<OpTrait> traits = []>
     : Op<PDL_Dialect, mnemonic, traits> {
   let printer = [{ ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
   let verifier = [{ return ::verify(*this); }];
 }
 
 //===----------------------------------------------------------------------===//
-// pdl::ApplyConstraintOp
+// pdl::ApplyNativeConstraintOp
 //===----------------------------------------------------------------------===//
 
-def PDL_ApplyConstraintOp
-    : PDL_Op<"apply_constraint", [HasParent<"pdl::PatternOp">]> {
-  let summary = "Apply a generic constraint to a set of provided entities";
+def PDL_ApplyNativeConstraintOp
+    : PDL_Op<"apply_native_constraint", [HasParent<"pdl::PatternOp">]> {
+  let summary = "Apply a native constraint to a set of provided entities";
   let description = [{
-    `apply_constraint` operations apply a generic constraint, that has been
-    registered externally with the consumer of PDL, to a given set of entities.
-    The constraint is permitted to accept any number of constant valued
-    parameters.
+    `pdl.apply_native_constraint` operations apply a native C++ constraint, that
+    has been registered externally with the consumer of PDL, to a given set of
+    entities. The constraint is permitted to accept any number of constant
+    valued parameters.
 
     Example:
 
     ```mlir
     // Apply `myConstraint` to the entities defined by `input`, `attr`, and
     // `op`. `42`, `"abc"`, and `i32` are constant parameters passed to the
     // constraint.
-    pdl.apply_constraint "myConstraint"[42, "abc", i32](%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation)
+    pdl.apply_native_constraint "myConstraint"[42, "abc", i32](%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation)
     ```
   }];
 
   let arguments = (ins StrAttr:$name,
                        Variadic<PDL_AnyType>:$args,
                        OptionalAttr<ArrayAttr>:$constParams);
   let assemblyFormat = [{
     $name ($constParams^)? `(` $args `:` type($args) `)` attr-dict
   }];
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, CArg<"ValueRange", "{}">:$args,
       CArg<"ArrayRef<Attribute>", "{}">:$params), [{
       build($_builder, $_state, $_builder.getStringAttr(name), args,
             params.empty() ? ArrayAttr() : $_builder.getArrayAttr(params));
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
+// pdl::ApplyNativeRewriteOp
+//===----------------------------------------------------------------------===//
+
+def PDL_ApplyNativeRewriteOp
+    : PDL_Op<"apply_native_rewrite", [HasParent<"pdl::RewriteOp">]> {
+  let summary = "Apply a native rewrite method inside of pdl.rewrite region";
+  let description = [{
+    `pdl.apply_native_rewrite` operations apply a native C++ function, that has
+    been registered externally with the consumer of PDL, to perform a rewrite
+    and optionally return a number of values. The native function may accept any
+    number of arguments and constant attribute parameters. This operation is
+    used within a pdl.rewrite region to enable the interleaving of native
+    rewrite methods with other pdl constructs.
+
+    Example:
+
+    ```mlir
+    // Apply a native rewrite method that returns an attribute.
+    %ret = pdl.apply_native_rewrite "myNativeFunc"[42, "gt"](%arg0, %arg1) : !pdl.attribute
+    ```
+
+    ```c++
+    // The native rewrite as defined in C++:
+    static void myNativeFunc(ArrayRef<PDLValue> args, ArrayAttr constantParams,
+                             PatternRewriter &rewriter,
+                             PDLResultList &results) {
+      Value arg0 = args[0].cast<Value>();
+      Value arg1 = args[1].cast<Value>();
+      IntegerAttr param0 = constantParams[0].cast<IntegerAttr>();
+      StringAttr param1 = constantParams[1].cast<StringAttr>();
+
+      // Just push back the first param attribute.
+      results.push_back(param0);
+    }
+
+    void registerNativeRewrite(PDLPatternModule &pdlModule) {
+      pdlModule.registerRewriteFunction("myNativeFunc", myNativeFunc);
+    }
+    ```
+  }];
+
+  let arguments = (ins StrAttr:$name,
+                       Variadic<PDL_AnyType>:$args,
+                       OptionalAttr<ArrayAttr>:$constParams);
+  let results = (outs Variadic<PDL_AnyType>:$results);
+  let assemblyFormat = [{
+    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)? `:` type($results)
+    attr-dict
+  }];
+}
+
+//===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
 def PDL_AttributeOp : PDL_Op<"attribute"> {
   let summary = "Define an input attribute in a pattern";
   let description = [{
     `pdl.attribute` operations capture named attribute edges into an operation.
     Instances of this operation define, and partially constrain, attributes of a
let builders = [
     }]>,
     OpBuilder<(ins "Attribute":$attr), [{
       build($_builder, $_state, $_builder.getType<AttributeType>(), Value(), attr);
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
-// pdl::CreateNativeOp
-//===----------------------------------------------------------------------===//
-
-def PDL_CreateNativeOp
-    : PDL_Op<"create_native", [HasParent<"pdl::RewriteOp">]> {
-  let summary = "Call a native creation method to construct an `Attribute`, "
-                "`Operation`, `Type`, or `Value`";
-  let description = [{
-    `pdl.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.create_native "myNativeFunc"[42, "gt"](%arg0, %arg1) : !pdl.attribute
-    ```
-  }];
-
-  let arguments = (ins StrAttr:$name,
-                       Variadic<PDL_AnyType>:$args,
-                       OptionalAttr<ArrayAttr>:$constParams);
-  let results = (outs PDL_AnyType:$result);
-  let assemblyFormat = [{
-    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)? `:` type($result)
-    attr-dict
-  }];
-  let verifier = ?;
-}
-
-//===----------------------------------------------------------------------===//
 // pdl::EraseOp
 //===----------------------------------------------------------------------===//
 
 def PDL_EraseOp : PDL_Op<"erase", [HasParent<"pdl::RewriteOp">]> {
   let summary = "Mark an input operation as `erased`";
   let description = [{
     `pdl.erase` operations are used within `pdl.rewrite` regions to specify that
     an input operation should be marked as erased. The semantics of this
let description = [{
 
     When used within a matching context, the name of the operation may be
     omitted.
 
     When used within a rewriting context, i.e. when defined within a
     `pdl.rewrite`, all of the result types must be "inferable". This means that
     the type must be attributable to either a constant type value or the result
     type of another entity, such as an attribute, the result of a
-    `createNative`, or the result type of another operation. If the result type
-    value does not meet any of these criteria, the operation must provide the
-    `InferTypeOpInterface` to ensure that the result types can be inferred.
+    `apply_native_rewrite`, or the result type of another operation. If the
+    result type value does not meet any of these criteria, the operation must
+    override the `InferTypeOpInterface` to ensure that the result types can be
+    inferred.
 
     Example:
 
     ```mlir
     // Define an instance of a `foo.op` operation.
     %op = pdl.operation "foo.op"(%arg0, %arg1) {"attrA" = %attr0} -> %type, %type, %type, %type
     ```
   }];

 
 def PDL_RewriteOp : PDL_Op<"rewrite", [
      Terminator, HasParent<"pdl::PatternOp">,
      SingleBlockImplicitTerminator<"pdl::RewriteEndOp">
   ]> {
   let summary = "Specify the rewrite of a matched pattern";
   let description = [{
     `pdl.rewrite` operations terminate the region of a `pdl.pattern` and specify
-    the rewrite of a `pdl.pattern`, on the specified root operation. The
+    the main rewrite of a `pdl.pattern`, on the specified root operation. The
     rewrite is specified either via a string name (`name`) to an external
     rewrite function, or via the region body. The rewrite region, if specified,
     must contain a single block and terminate via the `pdl.rewrite_end`
     operation. If the rewrite is external, it also takes a set of constant
     parameters and a set of additional positional values defined within the
-    matcher as arguments.
+    matcher as arguments. If the rewrite is external, the root operation is
+    passed to the native function as the first argument.
 
     Example:
 
     ```mlir
     // Specify an external rewrite function:
     pdl.rewrite %root with "myExternalRewriter"(%value : !pdl.value)
 
     // Specify the rewrite inline using PDL:

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

 // 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. The rewrite is passed the root operation being matched, a
-    set of additional positional arguments generated within the matcher, and a
-    set of constant parameters.
+    successful match. The rewrite is passed a set of positional arguments,
+    and a set of constant parameters. The rewrite function may return any
+    number of results.
 
     Example:
 
     ```mlir
     // Rewriter operating solely on the root operation.
-    pdl_interp.apply_rewrite "rewriter" on %root
+    pdl_interp.apply_rewrite "rewriter"(%root : !pdl.operation)
+
+    // Rewriter operating solely on the root operation and return an attribute.
+    %attr = pdl_interp.apply_rewrite "rewriter"(%root : !pdl.operation) : !pdl.attribute
 
     // Rewriter operating on the root operation along with additional arguments
     // from the matcher.
-    pdl_interp.apply_rewrite "rewriter"(%value : !pdl.value) on %root
+    pdl_interp.apply_rewrite "rewriter"(%root : !pdl.operation, %value : !pdl.value)
 
     // Rewriter operating on the root operation along with additional arguments
     // and constant parameters.
-    pdl_interp.apply_rewrite "rewriter"[42](%value : !pdl.value) on %root
+    pdl_interp.apply_rewrite "rewriter"[42](%root : !pdl.operation, %value : !pdl.value)
     ```
   }];
   let arguments = (ins StrAttr:$name,
-                       PDL_Operation:$root,
                        Variadic<PDL_AnyType>:$args,
                        OptionalAttr<ArrayAttr>:$constParams);
+  let results = (outs Variadic<PDL_AnyType>:$results);
   let assemblyFormat = [{
-    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)? `on` $root
-    attr-dict
+    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)?
+    (`:` type($results)^)? attr-dict
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::AreEqualOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_AreEqualOp
def PDLInterp_CreateAttributeOp
 
   let builders = [
     OpBuilder<(ins "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.value, !pdl.value) : !pdl.attribute
-    ```
-  }];
-
-  let arguments = (ins StrAttr:$name,
-                       Variadic<PDL_AnyType>:$args,
-                       OptionalAttr<ArrayAttr>:$constParams);
-  let results = (outs PDL_AnyType:$result);
-  let assemblyFormat = [{
-    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)? `:` 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

mlir/include/mlir/IR/PatternMatch.h

 };
 
 inline raw_ostream &operator<<(raw_ostream &os, PDLValue value) {
   value.print(os);
   return os;
 }
 
 //===----------------------------------------------------------------------===//
+// PDLResultList
+
+/// The class represents a list of PDL results, returned by a native rewrite
+/// method. It provides the mechanism with which to pass PDLValues back to the
+/// PDL bytecode.
+class PDLResultList {
+public:
+  /// Push a new Attribute value onto the result list.
+  void push_back(Attribute value) { results.push_back(value); }
+
+  /// Push a new Operation onto the result list.
+  void push_back(Operation *value) { results.push_back(value); }
+
+  /// Push a new Type onto the result list.
+  void push_back(Type value) { results.push_back(value); }
+
+  /// Push a new Value onto the result list.
+  void push_back(Value value) { results.push_back(value); }
+
+protected:
+  PDLResultList() = default;
+
+  /// The PDL results held by this list.
+  SmallVector<PDLValue> results;
+};
+
+//===----------------------------------------------------------------------===//
 // PDLPatternModule
 
 /// A generic PDL pattern constraint function. This function applies a
 /// constraint to a given set of opaque PDLValue entities. The second parameter
 /// is a set of constant value parameters specified in Attribute form. Returns
 /// success if the constraint successfully held, failure otherwise.
 using PDLConstraintFunction = std::function<LogicalResult(
     ArrayRef<PDLValue>, ArrayAttr, PatternRewriter &)>;
-/// A native PDL creation function. This function creates a new PDLValue given
-/// a set of existing PDL values, a set of constant parameters specified in
-/// Attribute form, and a PatternRewriter. Returns the newly created PDLValue.
-using PDLCreateFunction =
-    std::function<PDLValue(ArrayRef<PDLValue>, ArrayAttr, PatternRewriter &)>;
-/// A native PDL rewrite function. This function rewrites the given root
-/// operation using the provided PatternRewriter. This method is only invoked
-/// when the corresponding match was successful.
-using PDLRewriteFunction = std::function<void(Operation *, ArrayRef<PDLValue>,
-                                              ArrayAttr, PatternRewriter &)>;
+/// A native PDL rewrite function. This function performs a rewrite on the
+/// given set of values and constant parameters. Any results from this rewrite
+/// that should be passed back to PDL should be added to the provided result
+/// list. This method is only invoked when the corresponding match was
+/// successful.
+using PDLRewriteFunction = std::function<void(
+    ArrayRef<PDLValue>, ArrayAttr, PatternRewriter &, PDLResultList &)>;
 /// A generic PDL pattern constraint function. This function applies a
 /// constraint to a given opaque PDLValue entity. The second parameter is a set
 /// of constant value parameters specified in Attribute form. Returns success if
 /// the constraint successfully held, failure otherwise.
 using PDLSingleEntityConstraintFunction =
     std::function<LogicalResult(PDLValue, ArrayAttr, PatternRewriter &)>;
 
 /// This class contains all of the necessary data for a set of PDL patterns, or
registerConstraintFunction(
                   ArrayRef<PDLValue> values, ArrayAttr constantParams,
                   PatternRewriter &rewriter) {
           assert(values.size() == 1 &&
                  "expected values to have a single entity");
           return constraintFn(values[0], constantParams, rewriter);
         });
   }
 
-  /// Register a creation function.
-  void registerCreateFunction(StringRef name, PDLCreateFunction createFn);
-
   /// Register a rewrite function.
   void registerRewriteFunction(StringRef name, PDLRewriteFunction rewriteFn);
 
   /// Return the set of the registered constraint functions.
   const llvm::StringMap<PDLConstraintFunction> &getConstraintFunctions() const {
     return constraintFunctions;
   }
   llvm::StringMap<PDLConstraintFunction> takeConstraintFunctions() {
     return constraintFunctions;
   }
-  /// Return the set of the registered create functions.
-  const llvm::StringMap<PDLCreateFunction> &getCreateFunctions() const {
-    return createFunctions;
-  }
-  llvm::StringMap<PDLCreateFunction> takeCreateFunctions() {
-    return createFunctions;
-  }
   /// Return the set of the registered rewrite functions.
   const llvm::StringMap<PDLRewriteFunction> &getRewriteFunctions() const {
     return rewriteFunctions;
   }
   llvm::StringMap<PDLRewriteFunction> takeRewriteFunctions() {
     return rewriteFunctions;
   }
 
   /// Clear out the patterns and functions within this module.
   void clear() {
     pdlModule = nullptr;
     constraintFunctions.clear();
-    createFunctions.clear();
     rewriteFunctions.clear();
   }
 
 private:
   /// The module containing the `pdl.pattern` operations.
   OwningModuleRef pdlModule;
 
   /// The external functions referenced from within the PDL module.
   llvm::StringMap<PDLConstraintFunction> constraintFunctions;
-  llvm::StringMap<PDLCreateFunction> createFunctions;
   llvm::StringMap<PDLRewriteFunction> rewriteFunctions;
 };
 
 //===----------------------------------------------------------------------===//
 // RewriterBase
 //===----------------------------------------------------------------------===//
 
 /// This class coordinates the application of a rewrite on a set of IR,

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

void generateRecordMatch(Block *currentBlock, Block *nextBlock,
                            pdl::PatternOp pattern);
 
   /// Generate a rewriter function for the given pattern operation, and returns
   /// a reference to that function.
   SymbolRefAttr generateRewriter(pdl::PatternOp pattern,
                                  SmallVectorImpl<Position *> &usedMatchValues);
 
   /// Generate the rewriter code for the given operation.
+  void generateRewriter(pdl::ApplyNativeRewriteOp rewriteOp,
+                        DenseMap<Value, Value> &rewriteValues,
+                        function_ref<Value(Value)> mapRewriteValue);
   void generateRewriter(pdl::AttributeOp attrOp,
                         DenseMap<Value, Value> &rewriteValues,
                         function_ref<Value(Value)> mapRewriteValue);
   void generateRewriter(pdl::EraseOp eraseOp,
                         DenseMap<Value, Value> &rewriteValues,
                         function_ref<Value(Value)> mapRewriteValue);
   void generateRewriter(pdl::OperationOp operationOp,
                         DenseMap<Value, Value> &rewriteValues,
                         function_ref<Value(Value)> mapRewriteValue);
-  void generateRewriter(pdl::CreateNativeOp createNativeOp,
-                        DenseMap<Value, Value> &rewriteValues,
-                        function_ref<Value(Value)> mapRewriteValue);
   void generateRewriter(pdl::ReplaceOp replaceOp,
                         DenseMap<Value, Value> &rewriteValues,
                         function_ref<Value(Value)> mapRewriteValue);
   void generateRewriter(pdl::ResultOp resultOp,
                         DenseMap<Value, Value> &rewriteValues,
                         function_ref<Value(Value)> mapRewriteValue);
   void generateRewriter(pdl::TypeOp typeOp,
                         DenseMap<Value, Value> &rewriteValues,
auto mapRewriteValue = [&](Value oldValue) {
     usedMatchValues.push_back(inputPos);
     return newValue = rewriterFunc.front().addArgument(oldValue.getType());
   };
 
   // If this is a custom rewriter, simply dispatch to the registered rewrite
   // method.
   pdl::RewriteOp rewriter = pattern.getRewriter();
   if (StringAttr rewriteName = rewriter.nameAttr()) {
-    Value root = mapRewriteValue(rewriter.root());
-    SmallVector<Value, 4> args = llvm::to_vector<4>(
-        llvm::map_range(rewriter.externalArgs(), mapRewriteValue));
+    auto mappedArgs = llvm::map_range(rewriter.externalArgs(), mapRewriteValue);
+    SmallVector<Value, 4> args(1, mapRewriteValue(rewriter.root()));
+    args.append(mappedArgs.begin(), mappedArgs.end());
     builder.create<pdl_interp::ApplyRewriteOp>(
-        rewriter.getLoc(), rewriteName, root, args,
+        rewriter.getLoc(), /*resultTypes=*/TypeRange(), rewriteName, args,
         rewriter.externalConstParamsAttr());
   } else {
     // Otherwise this is a dag rewriter defined using PDL operations.
     for (Operation &rewriteOp : *rewriter.getBody()) {
       llvm::TypeSwitch<Operation *>(&rewriteOp)
-          .Case<pdl::AttributeOp, pdl::CreateNativeOp, pdl::EraseOp,
+          .Case<pdl::ApplyNativeRewriteOp, pdl::AttributeOp, pdl::EraseOp,
                 pdl::OperationOp, pdl::ReplaceOp, pdl::ResultOp, pdl::TypeOp>(
               [&](auto op) {
                 this->generateRewriter(op, rewriteValues, mapRewriteValue);
               });
     }
   }
 
   // Update the signature of the rewrite function.
   rewriterFunc.setType(builder.getFunctionType(
       llvm::to_vector<8>(rewriterFunc.front().getArgumentTypes()),
       /*results=*/llvm::None));
 
   builder.create<pdl_interp::FinalizeOp>(rewriter.getLoc());
   return builder.getSymbolRefAttr(
       pdl_interp::PDLInterpDialect::getRewriterModuleName(),
       builder.getSymbolRefAttr(rewriterFunc));
 }
 
 void PatternLowering::generateRewriter(
+    pdl::ApplyNativeRewriteOp rewriteOp, DenseMap<Value, Value> &rewriteValues,
+    function_ref<Value(Value)> mapRewriteValue) {
+  SmallVector<Value, 2> arguments;
+  for (Value argument : rewriteOp.args())
+    arguments.push_back(mapRewriteValue(argument));
+  auto interpOp = builder.create<pdl_interp::ApplyRewriteOp>(
+      rewriteOp.getLoc(), rewriteOp.getResultTypes(), rewriteOp.nameAttr(),
+      arguments, rewriteOp.constParamsAttr());
+  for (auto it : llvm::zip(rewriteOp.results(), interpOp.results()))
+    rewriteValues[std::get<0>(it)] = std::get<1>(it);
+}
+
+void PatternLowering::generateRewriter(
     pdl::AttributeOp attrOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   Value newAttr = builder.create<pdl_interp::CreateAttributeOp>(
       attrOp.getLoc(), attrOp.valueAttr());
   rewriteValues[attrOp] = newAttr;
 }
 
 void PatternLowering::generateRewriter(
for (auto it : llvm::enumerate(operationOp.types())) {
 
     Value getResultVal = builder.create<pdl_interp::GetResultOp>(
         loc, builder.getType<pdl::ValueType>(), createdOp, it.index());
     type = builder.create<pdl_interp::GetValueTypeOp>(loc, getResultVal);
   }
 }
 
 void PatternLowering::generateRewriter(
-    pdl::CreateNativeOp createNativeOp, DenseMap<Value, Value> &rewriteValues,
-    function_ref<Value(Value)> mapRewriteValue) {
-  SmallVector<Value, 2> arguments;
-  for (Value argument : createNativeOp.args())
-    arguments.push_back(mapRewriteValue(argument));
-  Value result = builder.create<pdl_interp::CreateNativeOp>(
-      createNativeOp.getLoc(), createNativeOp.result().getType(),
-      createNativeOp.nameAttr(), arguments, createNativeOp.constParamsAttr());
-  rewriteValues[createNativeOp] = result;
-}
-
-void PatternLowering::generateRewriter(
     pdl::ReplaceOp replaceOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   SmallVector<Value, 4> replOperands;
 
   // If the replacement was another operation, get its results. `pdl` allows
   // for using an operation for simplicitly, but the interpreter isn't as
   // user facing.
   if (Value replOp = replaceOp.replOperation()) {

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp

TypeSwitch<Position *>(pos)
             TypePosition>([&](auto *derivedPos) {
         getTreePredicates(predList, val, builder, inputs, derivedPos);
       })
       .Default([](auto *) { llvm_unreachable("unexpected position kind"); });
 }
 
 /// Collect all of the predicates related to constraints within the given
 /// pattern operation.
-static void getConstraintPredicates(pdl::ApplyConstraintOp op,
+static void getConstraintPredicates(pdl::ApplyNativeConstraintOp op,
                                     std::vector<PositionalPredicate> &predList,
                                     PredicateBuilder &builder,
                                     DenseMap<Value, Position *> &inputs) {
   OperandRange arguments = op.args();
   ArrayAttr parameters = op.constParamsAttr();
 
   std::vector<Position *> allPositions;
   allPositions.reserve(arguments.size());

 
 /// Collect all of the predicates that cannot be determined via walking the
 /// tree.
 static void getNonTreePredicates(pdl::PatternOp pattern,
                                  std::vector<PositionalPredicate> &predList,
                                  PredicateBuilder &builder,
                                  DenseMap<Value, Position *> &inputs) {
   for (Operation &op : pattern.body().getOps()) {
-    if (auto constraintOp = dyn_cast<pdl::ApplyConstraintOp>(&op))
+    if (auto constraintOp = dyn_cast<pdl::ApplyNativeConstraintOp>(&op))
       getConstraintPredicates(constraintOp, predList, builder, inputs);
     else if (auto resultOp = dyn_cast<pdl::ResultOp>(&op))
       getResultPredicates(resultOp, predList, builder, inputs);
   }
 }
 
 /// Given a pattern operation, build the set of matcher predicates necessary to
 /// match this pattern.

mlir/lib/Dialect/PDL/IR/PDL.cpp

verifyHasBindingUseInMatcher(Operation *op,
   if (hasBindingUseInMatcher(op, op->getBlock()))
     return success();
   return op->emitOpError()
          << "expected a bindable (i.e. " << bindableContextStr
          << ") user when defined in the matcher body of a `pdl.pattern`";
 }
 
 //===----------------------------------------------------------------------===//
-// pdl::ApplyConstraintOp
+// pdl::ApplyNativeConstraintOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(ApplyConstraintOp op) {
+static LogicalResult verify(ApplyNativeConstraintOp op) {
   if (op.getNumOperands() == 0)
     return op.emitOpError("expected at least one argument");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// pdl::ApplyNativeRewriteOp
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verify(ApplyNativeRewriteOp op) {
+  if (op.getNumOperands() == 0 && op.getNumResults() == 0)
+    return op.emitOpError("expected at least one argument or result");
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(AttributeOp op) {
   Value attrType = op.type();
   Optional<Attribute> attrValue = op.value();
 
   if (!attrValue && isa<RewriteOp>(op->getParentOp()))
static LogicalResult verifyResultTypesAreInferrable(OperationOp op,
   if (llvm::any_of(op.op().getUses(), canInferTypeFromUse))
     return success();
 
   // Otherwise, make sure each of the types can be inferred.
   for (auto it : llvm::enumerate(resultTypes)) {
     Operation *resultTypeOp = it.value().getDefiningOp();
     assert(resultTypeOp && "expected valid result type operation");
 
-    // If the op was defined by a `create_native`, it is guaranteed to be
+    // If the op was defined by a `apply_native_rewrite`, it is guaranteed to be
     // usable.
-    if (isa<CreateNativeOp>(resultTypeOp))
+    if (isa<ApplyNativeRewriteOp>(resultTypeOp))
       continue;
 
     // If the type is already constrained, there is nothing to do.
     TypeOp typeOp = cast<TypeOp>(resultTypeOp);
     if (typeOp.type())
       continue;
 
     // If the type operation was defined in the matcher and constrains the

mlir/lib/IR/PatternMatch.cpp

 
 void PDLPatternModule::mergeIn(PDLPatternModule &&other) {
   // Ignore the other module if it has no patterns.
   if (!other.pdlModule)
     return;
   // Steal the other state if we have no patterns.
   if (!pdlModule) {
     constraintFunctions = std::move(other.constraintFunctions);
-    createFunctions = std::move(other.createFunctions);
     rewriteFunctions = std::move(other.rewriteFunctions);
     pdlModule = std::move(other.pdlModule);
     return;
   }
   // Steal the functions of the other module.
   for (auto &it : constraintFunctions)
     registerConstraintFunction(it.first(), std::move(it.second));
-  for (auto &it : createFunctions)
-    registerCreateFunction(it.first(), std::move(it.second));
   for (auto &it : rewriteFunctions)
     registerRewriteFunction(it.first(), std::move(it.second));
 
   // Merge the pattern operations from the other module into this one.
   Block *block = pdlModule->getBody();
   block->getTerminator()->erase();
   block->getOperations().splice(block->end(),
                                 other.pdlModule->getBody()->getOperations());
 }
 
 //===----------------------------------------------------------------------===//
 // Function Registry
 
 void PDLPatternModule::registerConstraintFunction(
     StringRef name, PDLConstraintFunction constraintFn) {
   auto it = constraintFunctions.try_emplace(name, std::move(constraintFn));
   (void)it;
   assert(it.second &&
          "constraint with the given name has already been registered");
 }
-void PDLPatternModule::registerCreateFunction(StringRef name,
-                                              PDLCreateFunction createFn) {
-  auto it = createFunctions.try_emplace(name, std::move(createFn));
-  (void)it;
-  assert(it.second && "native create function with the given name has "
-                      "already been registered");
-}
+
 void PDLPatternModule::registerRewriteFunction(StringRef name,
                                                PDLRewriteFunction rewriteFn) {
   auto it = rewriteFunctions.try_emplace(name, std::move(rewriteFn));
   (void)it;
   assert(it.second && "native rewrite function with the given name has "
                       "already been registered");
 }
 

mlir/lib/Rewrite/ByteCode.h

struct MatchResult {
     /// The current benefit of the pattern that was matched.
     PatternBenefit benefit;
   };
 
   /// Create a ByteCode instance from the given module containing operations in
   /// the PDL interpreter dialect.
   PDLByteCode(ModuleOp module,
               llvm::StringMap<PDLConstraintFunction> constraintFns,
-              llvm::StringMap<PDLCreateFunction> createFns,
               llvm::StringMap<PDLRewriteFunction> rewriteFns);
 
   /// Return the patterns held by the bytecode.
   ArrayRef<PDLByteCodePattern> getPatterns() const { return patterns; }
 
   /// Initialize the given state such that it can be used to execute the current
   /// bytecode.
   void initializeMutableState(PDLByteCodeMutableState &state) const;
private:
   /// A vector containing the generated bytecode for all of the rewriters.
   SmallVector<ByteCodeField, 64> rewriterByteCode;
 
   /// The set of patterns contained within the bytecode.
   SmallVector<PDLByteCodePattern, 32> patterns;
 
   /// A set of user defined functions invoked via PDL.
   std::vector<PDLConstraintFunction> constraintFunctions;
-  std::vector<PDLCreateFunction> createFunctions;
   std::vector<PDLRewriteFunction> rewriteFunctions;
 
   /// The maximum memory index used by a value.
   ByteCodeField maxValueMemoryIndex = 0;
 };
 
 } // end namespace detail
 } // end namespace mlir
 
 #endif // MLIR_REWRITE_BYTECODE_H_

mlir/lib/Rewrite/ByteCode.cpp

enum OpCode : ByteCodeField {
   /// Unconditional branch.
   Branch,
   /// Compare the operand count of an operation with a constant.
   CheckOperandCount,
   /// Compare the name of an operation with a constant.
   CheckOperationName,
   /// Compare the result count of an operation with a constant.
   CheckResultCount,
-  /// Invoke a native creation method.
-  CreateNative,
   /// Create an operation.
   CreateOperation,
   /// Erase an operation.
   EraseOp,
   /// Terminate a matcher or rewrite sequence.
   Finalize,
   /// Get a specific attribute of an operation.
   GetAttribute,

 class Generator {
 public:
   Generator(MLIRContext *ctx, std::vector<const void *> &uniquedData,
             SmallVectorImpl<ByteCodeField> &matcherByteCode,
             SmallVectorImpl<ByteCodeField> &rewriterByteCode,
             SmallVectorImpl<PDLByteCodePattern> &patterns,
             ByteCodeField &maxValueMemoryIndex,
             llvm::StringMap<PDLConstraintFunction> &constraintFns,
-            llvm::StringMap<PDLCreateFunction> &createFns,
             llvm::StringMap<PDLRewriteFunction> &rewriteFns)
       : ctx(ctx), uniquedData(uniquedData), matcherByteCode(matcherByteCode),
         rewriterByteCode(rewriterByteCode), patterns(patterns),
         maxValueMemoryIndex(maxValueMemoryIndex) {
     for (auto it : llvm::enumerate(constraintFns))
       constraintToMemIndex.try_emplace(it.value().first(), it.index());
-    for (auto it : llvm::enumerate(createFns))
-      nativeCreateToMemIndex.try_emplace(it.value().first(), it.index());
     for (auto it : llvm::enumerate(rewriteFns))
       externalRewriterToMemIndex.try_emplace(it.value().first(), it.index());
   }
 
   /// Generate the bytecode for the given PDL interpreter module.
   void generate(ModuleOp module);
 
   /// Return the memory index to use for the given value.
private:
   void generate(pdl_interp::AreEqualOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::BranchOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::CheckAttributeOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::CheckOperandCountOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::CheckOperationNameOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::CheckResultCountOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::CheckTypeOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::CreateAttributeOp op, ByteCodeWriter &writer);
-  void generate(pdl_interp::CreateNativeOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::CreateOperationOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::CreateTypeOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::EraseOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::FinalizeOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::GetAttributeOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::GetAttributeTypeOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::GetDefiningOpOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::GetOperandOp op, ByteCodeWriter &writer);
private:
   /// Mapping from the name of an externally registered rewrite to its index in
   /// the bytecode registry.
   llvm::StringMap<ByteCodeField> externalRewriterToMemIndex;
 
   /// Mapping from the name of an externally registered constraint to its index
   /// in the bytecode registry.
   llvm::StringMap<ByteCodeField> constraintToMemIndex;
 
-  /// Mapping from the name of an externally registered creation method to its
-  /// index in the bytecode registry.
-  llvm::StringMap<ByteCodeField> nativeCreateToMemIndex;
-
   /// Mapping from rewriter function name to the bytecode address of the
   /// rewriter function in byte.
   llvm::StringMap<ByteCodeAddr> rewriterToAddr;
 
   /// Mapping from a uniqued storage object to its memory index within
   /// `uniquedData`.
   DenseMap<const void *, ByteCodeField> uniquedDataToMemIndex;
 

 
 void Generator::generate(Operation *op, ByteCodeWriter &writer) {
   TypeSwitch<Operation *>(op)
       .Case<pdl_interp::ApplyConstraintOp, pdl_interp::ApplyRewriteOp,
             pdl_interp::AreEqualOp, pdl_interp::BranchOp,
             pdl_interp::CheckAttributeOp, pdl_interp::CheckOperandCountOp,
             pdl_interp::CheckOperationNameOp, pdl_interp::CheckResultCountOp,
             pdl_interp::CheckTypeOp, pdl_interp::CreateAttributeOp,
-            pdl_interp::CreateNativeOp, pdl_interp::CreateOperationOp,
-            pdl_interp::CreateTypeOp, pdl_interp::EraseOp,
-            pdl_interp::FinalizeOp, pdl_interp::GetAttributeOp,
-            pdl_interp::GetAttributeTypeOp, pdl_interp::GetDefiningOpOp,
-            pdl_interp::GetOperandOp, pdl_interp::GetResultOp,
-            pdl_interp::GetValueTypeOp, pdl_interp::InferredTypeOp,
-            pdl_interp::IsNotNullOp, pdl_interp::RecordMatchOp,
-            pdl_interp::ReplaceOp, pdl_interp::SwitchAttributeOp,
-            pdl_interp::SwitchTypeOp, pdl_interp::SwitchOperandCountOp,
-            pdl_interp::SwitchOperationNameOp, pdl_interp::SwitchResultCountOp>(
+            pdl_interp::CreateOperationOp, pdl_interp::CreateTypeOp,
+            pdl_interp::EraseOp, pdl_interp::FinalizeOp,
+            pdl_interp::GetAttributeOp, pdl_interp::GetAttributeTypeOp,
+            pdl_interp::GetDefiningOpOp, pdl_interp::GetOperandOp,
+            pdl_interp::GetResultOp, pdl_interp::GetValueTypeOp,
+            pdl_interp::InferredTypeOp, pdl_interp::IsNotNullOp,
+            pdl_interp::RecordMatchOp, pdl_interp::ReplaceOp,
+            pdl_interp::SwitchAttributeOp, pdl_interp::SwitchTypeOp,
+            pdl_interp::SwitchOperandCountOp, pdl_interp::SwitchOperationNameOp,
+            pdl_interp::SwitchResultCountOp>(
           [&](auto interpOp) { this->generate(interpOp, writer); })
       .Default([](Operation *) {
         llvm_unreachable("unknown `pdl_interp` operation");
       });
 }
 
 void Generator::generate(pdl_interp::ApplyConstraintOp op,
                          ByteCodeWriter &writer) {
   assert(constraintToMemIndex.count(op.name()) &&
          "expected index for constraint function");
   writer.append(OpCode::ApplyConstraint, constraintToMemIndex[op.name()],
                 op.constParamsAttr());
   writer.appendPDLValueList(op.args());
   writer.append(op.getSuccessors());
 }
 void Generator::generate(pdl_interp::ApplyRewriteOp op,
                          ByteCodeWriter &writer) {
   assert(externalRewriterToMemIndex.count(op.name()) &&
          "expected index for rewrite function");
   writer.append(OpCode::ApplyRewrite, externalRewriterToMemIndex[op.name()],
-                op.constParamsAttr(), op.root());
+                op.constParamsAttr());
   writer.appendPDLValueList(op.args());
+
+#ifndef NDEBUG
+  // In debug mode we also append the number of results so that we can assert
+  // that the native creation function gave us the correct number of results.
+  writer.append(ByteCodeField(op.results().size()));
+#endif
+  for (Value result : op.results())
+    writer.append(result);
 }
 void Generator::generate(pdl_interp::AreEqualOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::AreEqual, op.lhs(), op.rhs(), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::BranchOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::Branch, SuccessorRange(op.getOperation()));
 }
 void Generator::generate(pdl_interp::CheckAttributeOp op,

 void Generator::generate(pdl_interp::CheckTypeOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::AreEqual, op.value(), op.type(), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::CreateAttributeOp op,
                          ByteCodeWriter &writer) {
   // Simply repoint the memory index of the result to the constant.
   getMemIndex(op.attribute()) = getMemIndex(op.value());
 }
-void Generator::generate(pdl_interp::CreateNativeOp op,
-                         ByteCodeWriter &writer) {
-  assert(nativeCreateToMemIndex.count(op.name()) &&
-         "expected index for creation function");
-  writer.append(OpCode::CreateNative, nativeCreateToMemIndex[op.name()],
-                op.result(), op.constParamsAttr());
-  writer.appendPDLValueList(op.args());
-}
 void Generator::generate(pdl_interp::CreateOperationOp op,
                          ByteCodeWriter &writer) {
   writer.append(OpCode::CreateOperation, op.operation(),
                 OperationName(op.name(), ctx), op.operands());
 
   // Add the attributes.
   OperandRange attributes = op.attributes();
   writer.append(static_cast<ByteCodeField>(attributes.size()));

 }
 
 //===----------------------------------------------------------------------===//
 // PDLByteCode
 //===----------------------------------------------------------------------===//
 
 PDLByteCode::PDLByteCode(ModuleOp module,
                          llvm::StringMap<PDLConstraintFunction> constraintFns,
-                         llvm::StringMap<PDLCreateFunction> createFns,
                          llvm::StringMap<PDLRewriteFunction> rewriteFns) {
   Generator generator(module.getContext(), uniquedData, matcherByteCode,
                       rewriterByteCode, patterns, maxValueMemoryIndex,
-                      constraintFns, createFns, rewriteFns);
+                      constraintFns, rewriteFns);
   generator.generate(module);
 
   // Initialize the external functions.
   for (auto &it : constraintFns)
     constraintFunctions.push_back(std::move(it.second));
-  for (auto &it : createFns)
-    createFunctions.push_back(std::move(it.second));
   for (auto &it : rewriteFns)
     rewriteFunctions.push_back(std::move(it.second));
 }
 
 /// Initialize the given state such that it can be used to execute the current
 /// bytecode.
 void PDLByteCode::initializeMutableState(PDLByteCodeMutableState &state) const {
   state.memory.resize(maxValueMemoryIndex, nullptr);

 public:
   ByteCodeExecutor(const ByteCodeField *curCodeIt,
                    MutableArrayRef<const void *> memory,
                    ArrayRef<const void *> uniquedMemory,
                    ArrayRef<ByteCodeField> code,
                    ArrayRef<PatternBenefit> currentPatternBenefits,
                    ArrayRef<PDLByteCodePattern> patterns,
                    ArrayRef<PDLConstraintFunction> constraintFunctions,
-                   ArrayRef<PDLCreateFunction> createFunctions,
                    ArrayRef<PDLRewriteFunction> rewriteFunctions)
       : curCodeIt(curCodeIt), memory(memory), uniquedMemory(uniquedMemory),
         code(code), currentPatternBenefits(currentPatternBenefits),
         patterns(patterns), constraintFunctions(constraintFunctions),
-        createFunctions(createFunctions), rewriteFunctions(rewriteFunctions) {}
+        rewriteFunctions(rewriteFunctions) {}
 
   /// Start executing the code at the current bytecode index. `matches` is an
   /// optional field provided when this function is executed in a matching
   /// context.
   void execute(PatternRewriter &rewriter,
                SmallVectorImpl<PDLByteCode::MatchResult> *matches = nullptr,
                Optional<Location> mainRewriteLoc = {});
 
 private:
   /// Internal implementation of executing each of the bytecode commands.
   void executeApplyConstraint(PatternRewriter &rewriter);
   void executeApplyRewrite(PatternRewriter &rewriter);
   void executeAreEqual();
   void executeBranch();
   void executeCheckOperandCount();
   void executeCheckOperationName();
   void executeCheckResultCount();
-  void executeCreateNative(PatternRewriter &rewriter);
   void executeCreateOperation(PatternRewriter &rewriter,
                               Location mainRewriteLoc);
   void executeEraseOp(PatternRewriter &rewriter);
   void executeGetAttribute();
   void executeGetAttributeType();
   void executeGetDefiningOp();
   void executeGetOperand(unsigned index);
   void executeGetResult(unsigned index);
private:
   MutableArrayRef<const void *> memory;
 
   /// References to ByteCode data necessary for execution.
   ArrayRef<const void *> uniquedMemory;
   ArrayRef<ByteCodeField> code;
   ArrayRef<PatternBenefit> currentPatternBenefits;
   ArrayRef<PDLByteCodePattern> patterns;
   ArrayRef<PDLConstraintFunction> constraintFunctions;
-  ArrayRef<PDLCreateFunction> createFunctions;
   ArrayRef<PDLRewriteFunction> rewriteFunctions;
 };
+
+/// This class is an instantiation of the PDLResultList that provides access to
+/// the returned results. This API is not on `PDLResultList` to avoid
+/// overexposing access to information specific solely to the ByteCode.
+class ByteCodeRewriteResultList : public PDLResultList {
+public:
+  /// Return the list of PDL results.
+  MutableArrayRef<PDLValue> getResults() { return results; }
+};
 } // end anonymous namespace
 
 void ByteCodeExecutor::executeApplyConstraint(PatternRewriter &rewriter) {
   LLVM_DEBUG(llvm::dbgs() << "Executing ApplyConstraint:\n");
   const PDLConstraintFunction &constraintFn = constraintFunctions[read()];
   ArrayAttr constParams = read<ArrayAttr>();
   SmallVector<PDLValue, 16> args;
   readList<PDLValue>(args);
 
   LLVM_DEBUG({
     llvm::dbgs() << "  * Arguments: ";
     llvm::interleaveComma(args, llvm::dbgs());
     llvm::dbgs() << "\n  * Parameters: " << constParams << "\n";
   });
 
   // Invoke the constraint and jump to the proper destination.
   selectJump(succeeded(constraintFn(args, constParams, rewriter)));
 }
 
 void ByteCodeExecutor::executeApplyRewrite(PatternRewriter &rewriter) {
   LLVM_DEBUG(llvm::dbgs() << "Executing ApplyRewrite:\n");
   const PDLRewriteFunction &rewriteFn = rewriteFunctions[read()];
   ArrayAttr constParams = read<ArrayAttr>();
-  Operation *root = read<Operation *>();
   SmallVector<PDLValue, 16> args;
   readList<PDLValue>(args);
 
   LLVM_DEBUG({
-    llvm::dbgs() << "  * Root: " << *root << "\n  * Arguments: ";
+    llvm::dbgs() << "  * Arguments: ";
     llvm::interleaveComma(args, llvm::dbgs());
     llvm::dbgs() << "\n  * Parameters: " << constParams << "\n";
   });
+  ByteCodeRewriteResultList results;
+  rewriteFn(args, constParams, rewriter, results);
+
+  // Store the results in the bytecode memory.
+#ifndef NDEBUG
+  ByteCodeField expectedNumberOfResults = read();
+  assert(results.getResults().size() == expectedNumberOfResults &&
+         "native PDL rewrite function returned unexpected number of results");
+#endif
 
-  // Invoke the native rewrite function.
-  rewriteFn(root, args, constParams, rewriter);
+  // Store the results in the bytecode memory.
+  for (PDLValue &result : results.getResults()) {
+    LLVM_DEBUG(llvm::dbgs() << "  * Result: " << result << "\n");
+    memory[read()] = result.getAsOpaquePointer();
+  }
 }
 
 void ByteCodeExecutor::executeAreEqual() {
   LLVM_DEBUG(llvm::dbgs() << "Executing AreEqual:\n");
   const void *lhs = read<const void *>();
   const void *rhs = read<const void *>();
 
   LLVM_DEBUG(llvm::dbgs() << "  * " << lhs << " == " << rhs << "\n");
void ByteCodeExecutor::executeCheckResultCount() {
   Operation *op = read<Operation *>();
   uint32_t expectedCount = read<uint32_t>();
 
   LLVM_DEBUG(llvm::dbgs() << "  * Found: " << op->getNumResults() << "\n"
                           << "  * Expected: " << expectedCount << "\n");
   selectJump(op->getNumResults() == expectedCount);
 }
 
-void ByteCodeExecutor::executeCreateNative(PatternRewriter &rewriter) {
-  LLVM_DEBUG(llvm::dbgs() << "Executing CreateNative:\n");
-  const PDLCreateFunction &createFn = createFunctions[read()];
-  ByteCodeField resultIndex = read();
-  ArrayAttr constParams = read<ArrayAttr>();
-  SmallVector<PDLValue, 16> args;
-  readList<PDLValue>(args);
-
-  LLVM_DEBUG({
-    llvm::dbgs() << "  * Arguments: ";
-    llvm::interleaveComma(args, llvm::dbgs());
-    llvm::dbgs() << "\n  * Parameters: " << constParams << "\n";
-  });
-
-  PDLValue result = createFn(args, constParams, rewriter);
-  memory[resultIndex] = result.getAsOpaquePointer();
-
-  LLVM_DEBUG(llvm::dbgs() << "  * Result: " << result << "\n");
-}
-
 void ByteCodeExecutor::executeCreateOperation(PatternRewriter &rewriter,
                                               Location mainRewriteLoc) {
   LLVM_DEBUG(llvm::dbgs() << "Executing CreateOperation:\n");
 
   unsigned memIndex = read();
   OperationState state(mainRewriteLoc, read<OperationName>());
   readList<Value>(state.operands);
   for (unsigned i = 0, e = read(); i != e; ++i) {
case CheckOperandCount:
       executeCheckOperandCount();
       break;
     case CheckOperationName:
       executeCheckOperationName();
       break;
     case CheckResultCount:
       executeCheckResultCount();
       break;
-    case CreateNative:
-      executeCreateNative(rewriter);
-      break;
     case CreateOperation:
       executeCreateOperation(rewriter, *mainRewriteLoc);
       break;
     case EraseOp:
       executeEraseOp(rewriter);
       break;
     case Finalize:
       LLVM_DEBUG(llvm::dbgs() << "Executing Finalize\n\n");
void PDLByteCode::match(Operation *op, PatternRewriter &rewriter,
                         SmallVectorImpl<MatchResult> &matches,
                         PDLByteCodeMutableState &state) const {
   // The first memory slot is always the root operation.
   state.memory[0] = op;
 
   // The matcher function always starts at code address 0.
   ByteCodeExecutor executor(matcherByteCode.data(), state.memory, uniquedData,
                             matcherByteCode, state.currentPatternBenefits,
-                            patterns, constraintFunctions, createFunctions,
-                            rewriteFunctions);
+                            patterns, constraintFunctions, rewriteFunctions);
   executor.execute(rewriter, &matches);
 
   // Order the found matches by benefit.
   std::stable_sort(matches.begin(), matches.end(),
                    [](const MatchResult &lhs, const MatchResult &rhs) {
                      return lhs.benefit > rhs.benefit;
                    });
 }
 
 /// Run the rewriter of the given pattern on the root operation `op`.
 void PDLByteCode::rewrite(PatternRewriter &rewriter, const MatchResult &match,
                           PDLByteCodeMutableState &state) const {
   // The arguments of the rewrite function are stored at the start of the
   // memory buffer.
   llvm::copy(match.values, state.memory.begin());
 
-  ByteCodeExecutor executor(
-      &rewriterByteCode[match.pattern->getRewriterAddr()], state.memory,
-      uniquedData, rewriterByteCode, state.currentPatternBenefits, patterns,
-      constraintFunctions, createFunctions, rewriteFunctions);
+  ByteCodeExecutor executor(&rewriterByteCode[match.pattern->getRewriterAddr()],
+                            state.memory, uniquedData, rewriterByteCode,
+                            state.currentPatternBenefits, patterns,
+                            constraintFunctions, rewriteFunctions);
   executor.execute(rewriter, /*matches=*/nullptr, match.location);
 }

mlir/lib/Rewrite/FrozenRewritePatternList.cpp

if (!pdlModule)
     return;
   if (failed(convertPDLToPDLInterp(pdlModule)))
     llvm::report_fatal_error(
         "failed to lower PDL pattern module to the PDL Interpreter");
 
   // Generate the pdl bytecode.
   impl->pdlByteCode = std::make_unique<detail::PDLByteCode>(
       pdlModule, pdlPatterns.takeConstraintFunctions(),
-      pdlPatterns.takeCreateFunctions(), pdlPatterns.takeRewriteFunctions());
+      pdlPatterns.takeRewriteFunctions());
 }
 
 FrozenRewritePatternList::~FrozenRewritePatternList() {}

mlir/test/Conversion/PDLToPDLInterp/pdl-to-pdl-interp-matcher.mlir

module @simple {
   // CHECK: ^bb3:
   // CHECK:   pdl_interp.check_result_count of %[[ROOT]] is 0 -> ^bb4, ^bb1
   // CHECK: ^bb4:
   // CHECK:   pdl_interp.record_match @rewriters::@pdl_generated_rewriter
   // CHECK-SAME: benefit(1), loc([%[[ROOT]]]), root("foo.op") -> ^bb1
 
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[REWRITE_ROOT:.*]]: !pdl.operation)
-  // CHECK:     pdl_interp.apply_rewrite "rewriter" on %[[REWRITE_ROOT]]
+  // CHECK:     pdl_interp.apply_rewrite "rewriter"(%[[REWRITE_ROOT]]
   // CHECK:     pdl_interp.finalize
   pdl.pattern : benefit(1) {
     %root = pdl.operation "foo.op"()
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
module @constraints {
   // CHECK:       pdl_interp.apply_constraint "multi_constraint" [true](%[[INPUT]], %[[INPUT1]], %[[RESULT]]
 
   pdl.pattern : benefit(1) {
     %input0 = pdl.operand
     %input1 = pdl.operand
     %root = pdl.operation(%input0, %input1)
     %result0 = pdl.result 0 of %root
 
-    pdl.apply_constraint "multi_constraint"[true](%input0, %input1, %result0 : !pdl.value, !pdl.value, !pdl.value)
+    pdl.apply_native_constraint "multi_constraint"[true](%input0, %input1, %result0 : !pdl.value, !pdl.value, !pdl.value)
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @inputs
 module @inputs {
module @predicate_ordering  {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK-NEXT: pdl_interp.is_not_null %[[RESULT]]
   // CHECK:   %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
   // CHECK: pdl_interp.apply_constraint "typeConstraint" [](%[[RESULT_TYPE]]
 
   pdl.pattern : benefit(1) {
     %resultType = pdl.type
-    pdl.apply_constraint "typeConstraint"[](%resultType : !pdl.type)
+    pdl.apply_native_constraint "typeConstraint"[](%resultType : !pdl.type)
     %root = pdl.operation -> %resultType
     pdl.rewrite %root with "rewriter"
   }
 
   pdl.pattern : benefit(1) {
     %resultType = pdl.type
     %apply = pdl.operation -> %resultType
     pdl.rewrite %apply with "rewriter"
   }
 }

mlir/test/Conversion/PDLToPDLInterp/pdl-to-pdl-interp-rewriter.mlir

 // RUN: mlir-opt -split-input-file -convert-pdl-to-pdl-interp %s | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: module @external
 module @external {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation, %[[INPUT:.*]]: !pdl.value)
-  // CHECK:     pdl_interp.apply_rewrite "rewriter" [true](%[[INPUT]] : !pdl.value) on %[[ROOT]]
+  // CHECK:     pdl_interp.apply_rewrite "rewriter" [true](%[[ROOT]], %[[INPUT]] : !pdl.operation, !pdl.value)
   pdl.pattern : benefit(1) {
     %input = pdl.operand
     %root = pdl.operation "foo.op"(%input)
     pdl.rewrite %root with "rewriter"[true](%input : !pdl.value)
   }
 }
 
 // -----
pdl.rewrite %root {
       %newOp = pdl.operation "foo.op"
       pdl.replace %root with %newOp
     }
   }
 }
 
 // -----
 
-// CHECK-LABEL: module @create_native
-module @create_native {
+// CHECK-LABEL: module @apply_native_rewrite
+module @apply_native_rewrite {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
-  // CHECK:     %[[TYPE:.*]] = pdl_interp.create_native "functor" [true](%[[ROOT]] : !pdl.operation) : !pdl.type
+  // CHECK:     %[[TYPE:.*]] = pdl_interp.apply_rewrite "functor" [true](%[[ROOT]] : !pdl.operation) : !pdl.type
   // CHECK:     pdl_interp.create_operation "foo.op"() -> %[[TYPE]]
   pdl.pattern : benefit(1) {
     %type = pdl.type
     %root = pdl.operation "foo.op" -> %type
     pdl.rewrite %root {
-      %newType = pdl.create_native "functor"[true](%root : !pdl.operation) : !pdl.type
+      %newType = pdl.apply_native_rewrite "functor"[true](%root : !pdl.operation) : !pdl.type
       %newOp = pdl.operation "foo.op" -> %newType
       pdl.replace %root with %newOp
     }
   }
 }

mlir/test/Dialect/PDL/invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 //===----------------------------------------------------------------------===//
-// pdl::ApplyConstraintOp
+// pdl::ApplyNativeConstraintOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   %op = pdl.operation "foo.op"
 
   // expected-error@below {{expected at least one argument}}
-  "pdl.apply_constraint"() {name = "foo", params = []} : () -> ()
+  "pdl.apply_native_constraint"() {name = "foo", params = []} : () -> ()
   pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// pdl::ApplyNativeRewriteOp
+//===----------------------------------------------------------------------===//
+
+pdl.pattern : benefit(1) {
+  %op = pdl.operation "foo.op"
+  pdl.rewrite %op {
+    // expected-error@below {{expected at least one argument}}
+    "pdl.apply_native_rewrite"() {name = "foo", params = []} : () -> ()
+  }
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   %type = pdl.type
 
   // expected-error@below {{expected only one of [`type`, `value`] to be set}}
   %attr = pdl.attribute : %type 10

mlir/test/Rewrite/pdl-bytecode.mlir

module @patterns {
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
     func @success(%root : !pdl.operation) {
       %operand = pdl_interp.get_operand 0 of %root
-      pdl_interp.apply_rewrite "rewriter"[42](%operand : !pdl.value) on %root
+      pdl_interp.apply_rewrite "rewriter"[42](%root, %operand : !pdl.operation, !pdl.value)
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.apply_rewrite_1
 // CHECK: %[[INPUT:.*]] = "test.op_input"
 // CHECK-NOT: "test.op"
 // CHECK: "test.success"(%[[INPUT]]) {constantParams = [42]}
 module @ir attributes { test.apply_rewrite_1 } {
   %input = "test.op_input"() : () -> i32
   "test.op"(%input) : (i32) -> ()
 }
+
+// -----
+
+module @patterns {
+  func @matcher(%root : !pdl.operation) {
+    pdl_interp.check_operation_name of %root is "test.op" -> ^pat, ^end
+
+  ^pat:
+    pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
+
+  ^end:
+    pdl_interp.finalize
+  }
+
+  module @rewriters {
+    func @success(%root : !pdl.operation) {
+      %op = pdl_interp.apply_rewrite "creator"(%root : !pdl.operation) : !pdl.operation
+      pdl_interp.erase %root
+      pdl_interp.finalize
+    }
+  }
+}
+
+// CHECK-LABEL: test.apply_rewrite_2
+// CHECK: "test.success"
+module @ir attributes { test.apply_rewrite_2 } {
+  "test.op"() : () -> ()
+}
+
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::AreEqualOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
   func @matcher(%root : !pdl.operation) {

 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateAttributeOp
 //===----------------------------------------------------------------------===//
 
 // Fully tested within the tests for other operations.
 
 //===----------------------------------------------------------------------===//
-// pdl_interp::CreateNativeOp
-//===----------------------------------------------------------------------===//
-
-// -----
-
-module @patterns {
-  func @matcher(%root : !pdl.operation) {
-    pdl_interp.check_operation_name of %root is "test.op" -> ^pat, ^end
-
-  ^pat:
-    pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
-
-  ^end:
-    pdl_interp.finalize
-  }
-
-  module @rewriters {
-    func @success(%root : !pdl.operation) {
-      %op = pdl_interp.create_native "creator"(%root : !pdl.operation) : !pdl.operation
-      pdl_interp.erase %root
-      pdl_interp.finalize
-    }
-  }
-}
-
-// CHECK-LABEL: test.create_native_1
-// CHECK: "test.success"
-module @ir attributes { test.create_native_1 } {
-  "test.op"() : () -> ()
-}
-
-//===----------------------------------------------------------------------===//
 // pdl_interp::CreateOperationOp
 //===----------------------------------------------------------------------===//
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateTypeOp
 //===----------------------------------------------------------------------===//

mlir/test/lib/Rewrite/TestPDLByteCode.cpp

 }
 static LogicalResult customMultiEntityConstraint(ArrayRef<PDLValue> values,
                                                  ArrayAttr constantParams,
                                                  PatternRewriter &rewriter) {
   return customSingleEntityConstraint(values[1], constantParams, rewriter);
 }
 
 // Custom creator invoked from PDL.
-static PDLValue customCreate(ArrayRef<PDLValue> args, ArrayAttr constantParams,
-                             PatternRewriter &rewriter) {
-  return rewriter.createOperation(
-      OperationState(args[0].cast<Operation *>()->getLoc(), "test.success"));
+static void customCreate(ArrayRef<PDLValue> args, ArrayAttr constantParams,
+                         PatternRewriter &rewriter, PDLResultList &results) {
+  results.push_back(rewriter.createOperation(
+      OperationState(args[0].cast<Operation *>()->getLoc(), "test.success")));
 }
 
 /// Custom rewriter invoked from PDL.
-static void customRewriter(Operation *root, ArrayRef<PDLValue> args,
-                           ArrayAttr constantParams,
-                           PatternRewriter &rewriter) {
+static void customRewriter(ArrayRef<PDLValue> args, ArrayAttr constantParams,
+                           PatternRewriter &rewriter, PDLResultList &results) {
+  Operation *root = args[0].cast<Operation *>();
   OperationState successOpState(root->getLoc(), "test.success");
-  successOpState.addOperands(args[0].cast<Value>());
+  successOpState.addOperands(args[1].cast<Value>());
   successOpState.addAttribute("constantParams", constantParams);
   rewriter.createOperation(successOpState);
   rewriter.eraseOp(root);
 }
 
 namespace {
 struct TestPDLByteCodePass
     : public PassWrapper<TestPDLByteCodePass, OperationPass<ModuleOp>> {
void runOnOperation() final {
 
     // Process the pattern module.
     patternModule.getOperation()->remove();
     PDLPatternModule pdlPattern(patternModule);
     pdlPattern.registerConstraintFunction("multi_entity_constraint",
                                           customMultiEntityConstraint);
     pdlPattern.registerConstraintFunction("single_entity_constraint",
                                           customSingleEntityConstraint);
-    pdlPattern.registerCreateFunction("creator", customCreate);
+    pdlPattern.registerRewriteFunction("creator", customCreate);
     pdlPattern.registerRewriteFunction("rewriter", customRewriter);
 
     OwningRewritePatternList patternList(std::move(pdlPattern));
 
     // Invoke the pattern driver with the provided patterns.
     (void)applyPatternsAndFoldGreedily(irModule.getBodyRegion(),
                                        std::move(patternList));
   }