[mlir][Vector] Drop use of FuncOp in transferOpflowOpt

[rriddle]

Summary

FuncOp isn't really important to hardcode here, it is only used to act
as a root operation for the transformation.

mlir/include/mlir/Dialect/Vector/Transforms/VectorTransforms.h

 /// %nv = vector.insert_map %ev, %id, 32 : vector<1xf32> into vector<32xf32>
 Optional<DistributeOps>
 distributPointwiseVectorOp(OpBuilder &builder, Operation *op,
                            ArrayRef<Value> id, ArrayRef<int64_t> multiplicity,
                            const AffineMap &map);
 
 /// Implements transfer op write to read forwarding and dead transfer write
 /// optimizations.
-void transferOpflowOpt(FuncOp func);
+void transferOpflowOpt(Operation *rootOp);
 
 } // namespace vector
 } // namespace mlir
 
 #endif // MLIR_DIALECT_VECTOR_TRANSFORMS_VECTORTRANSFORMS_H

mlir/lib/Dialect/Vector/Transforms/VectorTransferOpTransforms.cpp

for (; op != nullptr && op->getParentRegion() != region;
     ;
   return op;
 }
 
 namespace {
 
 class TransferOptimization {
 public:
-  TransferOptimization(FuncOp func) : dominators(func), postDominators(func) {}
+  TransferOptimization(Operation *op) : dominators(op), postDominators(op) {}
   void deadStoreOp(vector::TransferWriteOp);
   void storeToLoadForwarding(vector::TransferReadOp);
   void removeDeadOp() {
     for (Operation *op : opToErase)
       op->erase();
     opToErase.clear();
   }
 
rewriter.create<vector::TransferWriteOp>(loc, vector1d, source1d,
                                              ValueRange{c0}, identityMap1D);
     rewriter.eraseOp(transferWriteOp);
     return success();
   }
 };
 
 } // namespace
 
-void mlir::vector::transferOpflowOpt(FuncOp func) {
-  TransferOptimization opt(func);
+void mlir::vector::transferOpflowOpt(Operation *rootOp) {
+  TransferOptimization opt(rootOp);
   // Run store to load forwarding first since it can expose more dead store
   // opportunity.
-  func.walk([&](vector::TransferReadOp read) {
+  rootOp->walk([&](vector::TransferReadOp read) {
     if (read.getShapedType().isa<MemRefType>())
       opt.storeToLoadForwarding(read);
   });
   opt.removeDeadOp();
-  func.walk([&](vector::TransferWriteOp write) {
+  rootOp->walk([&](vector::TransferWriteOp write) {
     if (write.getShapedType().isa<MemRefType>())
       opt.deadStoreOp(write);
   });
   opt.removeDeadOp();
 }
 
 void mlir::vector::populateVectorTransferDropUnitDimsPatterns(
     RewritePatternSet &patterns) {