[mlir] GreedyPatternRewriteDriver: Do not enqueue operands of deleted ops

[springerm]

Summary

Only ops that were newly inserted or changed should be enqueued.

Patterns can match based on their operands but not based on the uses of their results.

Depends On: D144257

[springerm]

This change is needed for D144193. Otherwise, we may enqueue deleted operations when removing an op op such as:

"op"() {
 // graph region
  %a = "foo"(%b)
  %b = "foo"(%a)
}

The alternative would be to immediately erase an op after triggering notifyOperationRemoved. I.e., a walk over the op that removes nested ops one-by-one and triggers notifications. This would be less efficient than what we are doing now: a walk over an operation to send notifications, followed by a single Operation::erase (that also drops all nested ops).

[springerm]

remove dead code

[springerm]

One problem with this approach is that it increases the number of iterations needed for convergence.

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

protected:
 
   /// The list of ops we are restricting our rewrites to. These include the
   /// supplied set of ops as well as new ops created while rewriting those ops
   /// depending on `strictMode`. This set is not maintained when
   /// `config.strictMode` is GreedyRewriteStrictness::AnyOp.
   llvm::SmallDenseSet<Operation *, 4> strictModeFilteredOps;
 
 private:
-  /// Look over the provided operands for any defining operations that should
-  /// be re-added to the worklist. This function should be called when an
-  /// operation is modified or removed, as it may trigger further
-  /// simplifications.
-  void addOperandsToWorklist(ValueRange operands);
-
   /// Pop the next operation from the worklist.
   Operation *popFromWorklist();
 
   /// Notify the driver that the given block was created.
   void notifyBlockCreated(Block *block) override;
 
   /// For debugging only: Notify the driver of a pattern match failure.
   LogicalResult

 void GreedyPatternRewriteDriver::notifyOperationModified(Operation *op) {
   LLVM_DEBUG({
     logger.startLine() << "** Modified: '" << op->getName() << "'(" << op
                        << ")\n";
   });
   addToWorklist(op);
 }
 
-void GreedyPatternRewriteDriver::addOperandsToWorklist(ValueRange operands) {
-  for (Value operand : operands) {
-    // If the use count of this operand is now < 2, we re-add the defining
-    // operation to the worklist.
-    // TODO: This is based on the fact that zero use operations
-    // may be deleted, and that single use values often have more
-    // canonicalization opportunities.
-    if (!operand || (!operand.use_empty() && !operand.hasOneUse()))
-      continue;
-    if (auto *defOp = operand.getDefiningOp())
-      addToWorklist(defOp);
-  }
-}
-
 void GreedyPatternRewriteDriver::notifyOperationRemoved(Operation *op) {
   LLVM_DEBUG({
     logger.startLine() << "** Erase   : '" << op->getName() << "'(" << op
                        << ")\n";
   });
   if (config.listener)
     config.listener->notifyOperationRemoved(op);
 
-  addOperandsToWorklist(op->getOperands());
   op->walk([this](Operation *operation) {
     removeFromWorklist(operation);
     folder.notifyRemoval(operation);
   });
 
   if (config.strictMode != GreedyRewriteStrictness::AnyOp)
     strictModeFilteredOps.erase(op);
 }