[mlir] Allow overriding AbstractDenseDataFlowAnalysis::visitOperation

[tblah]

Summary

AbstractDenseDataFlowAnalysis::visitOperation controls how the dataflow
analysis proceeds around control flow. In particular, conservative
assumptions are made about call operations which can prevent some
analysis from succeeding.

The motivating case for this change is https://reviews.llvm.org/D140415,
for which it is correct and necessary for the lattice to be preserved
after call operations.

Some renaming was necessary to avoid confusion with
DenseDataFlowAnalysis::visitOperation.
AbstractDenseDataFlowAnalysis::visitRegionBranchOperation and
DenseDataFlowAnalysis::visitOperationImpl are also made protected
to allow implementation of AbstractDenseDataFlowAnalysis::visitOperation,
although I did not need these to be virtual.

[Mogball]

+1 but why is the rename necessary? From what I understand, the name shouldn't conflict with any other method...

[tblah]

In D140879#4023248, @Mogball wrote:

+1 but why is the rename necessary? From what I understand, the name shouldn't conflict with any other method...

Thanks for taking a look.

The rename is necessary because builds using clang with LLVM_ENABLE_WERROR=On will fail on 'mlir::dataflow::DenseDataFlowAnalysis<(anonymous namespace)::LastModification::visitOperation' hides overloaded virtual function [-Werror,-Woverloaded-virtual].

Besides the compilation warning, I think it is confusing to have two methods with the same name that do different things.

[Mogball]

Thanks for the clarification. Can you name it something like processOperation? "CFG" isn't really applicable here since it has nothing to do with "control-flow graphs" specifically.

mlir/include/mlir/Analysis/DataFlow/DenseAnalysis.h

protected:
   /// if it changed.
   virtual void setToEntryState(AbstractDenseLattice *lattice) = 0;
 
   /// Join a lattice with another and propagate an update if it changed.
   void join(AbstractDenseLattice *lhs, const AbstractDenseLattice &rhs) {
     propagateIfChanged(lhs, lhs->join(rhs));
   }
 
-private:
   /// Visit an operation. If this is a call operation or region control-flow
   /// operation, then the state after the execution of the operation is set by
   /// control-flow or the callgraph. Otherwise, this function invokes the
   /// operation transfer function.
-  void visitOperation(Operation *op);
-
-  /// Visit a block. The state at the start of the block is propagated from
-  /// control-flow predecessors or callsites
-  void visitBlock(Block *block);
+  virtual void processOperation(Operation *op);
 
   /// Visit a program point within a region branch operation with predecessors
   /// in it. This can either be an entry block of one of the regions of the
   /// parent operation itself.
   void visitRegionBranchOperation(ProgramPoint point,
                                   RegionBranchOpInterface branch,
                                   AbstractDenseLattice *after);
+
+private:
+  /// Visit a block. The state at the start of the block is propagated from
+  /// control-flow predecessors or callsites
+  void visitBlock(Block *block);
 };
 
 //===----------------------------------------------------------------------===//
 // DenseDataFlowAnalysis
 //===----------------------------------------------------------------------===//
 
 /// A dense (forward) data-flow analysis for propagating lattices before and
 /// after the execution of every operation across the IR by implementing
protected:
 
   /// Set the dense lattice at control flow entry point and propagate an update
   /// if it changed.
   virtual void setToEntryState(LatticeT *lattice) = 0;
   void setToEntryState(AbstractDenseLattice *lattice) override {
     setToEntryState(static_cast<LatticeT *>(lattice));
   }
 
-private:
   /// Type-erased wrappers that convert the abstract dense lattice to a derived
   /// lattice and invoke the virtual hooks operating on the derived lattice.
   void visitOperationImpl(Operation *op, const AbstractDenseLattice &before,
                           AbstractDenseLattice *after) override {
     visitOperation(op, static_cast<const LatticeT &>(before),
                    static_cast<LatticeT *>(after));
   }
 };
 
 } // end namespace dataflow
 } // end namespace mlir
 
 #endif // MLIR_ANALYSIS_DENSEDATAFLOWANALYSIS_H

mlir/lib/Analysis/DataFlow/DenseAnalysis.cpp

 using namespace mlir::dataflow;
 
 //===----------------------------------------------------------------------===//
 // AbstractDenseDataFlowAnalysis
 //===----------------------------------------------------------------------===//
 
 LogicalResult AbstractDenseDataFlowAnalysis::initialize(Operation *top) {
   // Visit every operation and block.
-  visitOperation(top);
+  processOperation(top);
   for (Region &region : top->getRegions()) {
     for (Block &block : region) {
       visitBlock(&block);
       for (Operation &op : block)
         if (failed(initialize(&op)))
           return failure();
     }
   }
   return success();
 }
 
 LogicalResult AbstractDenseDataFlowAnalysis::visit(ProgramPoint point) {
   if (auto *op = point.dyn_cast<Operation *>())
-    visitOperation(op);
+    processOperation(op);
   else if (auto *block = point.dyn_cast<Block *>())
     visitBlock(block);
   else
     return failure();
   return success();
 }
 
-void AbstractDenseDataFlowAnalysis::visitOperation(Operation *op) {
+void AbstractDenseDataFlowAnalysis::processOperation(Operation *op) {
   // If the containing block is not executable, bail out.
   if (!getOrCreateFor<Executable>(op, op->getBlock())->isLive())
     return;
 
   // Get the dense lattice to update.
   AbstractDenseLattice *after = getLattice(op);
 
   // If this op implements region control-flow, then control-flow dictates its