[mlir:PDL] Set debug name for PDL match result patterns

[shidahe]

Summary

A PDL match result pattern doesn't have a debug name, which is what
"debug-only=greedy-rewriter" prints out during rewrite. So it's hard to find
out which PDL pattern is being applied from the debug log.

This commit names the generated rewriter in PDLInterp with the optional
attribute "sym_name" of PDL PatternOp. Then the name of a PDL pattern can be
set as debug name of its match result PDLByteCodePattern.

[shidahe]

Remove a duplicated line

[shidahe]

Use prefixed accessors

[sfuniak]

Looks good to me--a much needed improvement! However, someone with a more recent knowledge of PDL should review as well.

[shidahe]

Use std::optional value_or

[shidahe]

@rriddle Thank you for the approval! Since I don't have commit access, could you please help commit this change?

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

void PatternLowering::generate(SuccessNode *successNode, Block *&currentBlock) {
   if (configMap)
     configMap->try_emplace(matchOp, configMap->lookup(pattern));
 }
 
 SymbolRefAttr PatternLowering::generateRewriter(
     pdl::PatternOp pattern, SmallVectorImpl<Position *> &usedMatchValues) {
   builder.setInsertionPointToEnd(rewriterModule.getBody());
   auto rewriterFunc = builder.create<pdl_interp::FuncOp>(
-      pattern.getLoc(), "pdl_generated_rewriter",
+      pattern.getLoc(), pattern.getSymName().value_or("pdl_generated_rewriter"),
       builder.getFunctionType(std::nullopt, std::nullopt));
   rewriterSymbolTable.insert(rewriterFunc);
 
   // Generate the rewriter function body.
   builder.setInsertionPointToEnd(&rewriterFunc.front());
 
   // Map an input operand of the pattern to a generated interpreter value.
   DenseMap<Value, Value> rewriteValues;

mlir/lib/Rewrite/ByteCode.cpp

if (op.getType().isa<pdl::RangeType>()) {
     writer.append(OpCode::GetValueType, op.getResult(), op.getValue());
   }
 }
 void Generator::generate(pdl_interp::IsNotNullOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::IsNotNull, op.getValue(), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::RecordMatchOp op, ByteCodeWriter &writer) {
   ByteCodeField patternIndex = patterns.size();
-  patterns.emplace_back(PDLByteCodePattern::create(
-      op, configMap.lookup(op),
-      rewriterToAddr[op.getRewriter().getLeafReference().getValue()]));
+  auto rewriterName = op.getRewriter().getLeafReference().getValue();
+  auto pattern = PDLByteCodePattern::create(op, configMap.lookup(op),
+                                            rewriterToAddr[rewriterName]);
+  pattern.setDebugName(rewriterName);
+  patterns.emplace_back(std::move(pattern));
   writer.append(OpCode::RecordMatch, patternIndex,
                 SuccessorRange(op.getOperation()), op.getMatchedOps());
   writer.appendPDLValueList(op.getInputs());
 }
 void Generator::generate(pdl_interp::ReplaceOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::ReplaceOp, op.getInputOp());
   writer.appendPDLValueList(op.getReplValues());
 }

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

pdl.pattern : benefit(1) {
     %input = operand
     %root = operation "foo.op"(%input : !pdl.value)
     rewrite %root with "rewriter"(%input : !pdl.value)
   }
 }
 
 // -----
 
+// CHECK-LABEL: module @named_pattern
+module @named_pattern {
+  // CHECK: module @rewriters
+  // CHECK:   func @pattern_sym_name(%[[ROOT:.*]]: !pdl.operation, %[[INPUT:.*]]: !pdl.value)
+  // CHECK:     pdl_interp.apply_rewrite "rewriter"(%[[ROOT]], %[[INPUT]] : !pdl.operation, !pdl.value)
+  pdl.pattern @pattern_sym_name : benefit(1) {
+    %input = operand
+    %root = operation "foo.op"(%input : !pdl.value)
+    rewrite %root with "rewriter"(%input : !pdl.value)
+  }
+}
+
+// -----
+
 // CHECK-LABEL: module @erase
 module @erase {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:     pdl_interp.erase %[[ROOT]]
   // CHECK:     pdl_interp.finalize
   pdl.pattern : benefit(1) {
     %root = operation "foo.op"