[MLIR] Fix non-deterministic generation from buffer-deallocation pass

[bondhugula]

Summary

The buffer-deallocation pass generates a different output on each run
due to an unstable iteration order.

Fixes: https://github.com/llvm/llvm-project/issues/59118

mlir/include/mlir/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.h

public:
   /// A = *
   /// B = subview(A)
   /// C = B
   ///
   /// Results in resolve(B) returning {B, C}
   ValueSetT resolve(Value value) const;
 
   /// Removes the given values from all alias sets.
-  void remove(const SmallPtrSetImpl<Value> &aliasValues);
+  void remove(const SetVector<Value> &aliasValues);
 
 private:
   /// This function constructs a mapping from values to its immediate
   /// dependencies.
   void build(Operation *op);
 
   /// Maps values to all immediate dependencies this value can have.
   ValueMapT dependencies;
 };
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERVIEWFLOWANALYSIS_H

mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp

public:
   }
 
 private:
   /// Introduces required clone operations to avoid memory leaks.
   LogicalResult introduceClones() {
     // Initialize the set of values that require a dedicated memory free
     // operation since their operands cannot be safely deallocated in a post
     // dominator.
-    SmallPtrSet<Value, 8> valuesToFree;
+    SetVector<Value> valuesToFree;
     llvm::SmallDenseSet<std::tuple<Value, Block *>> visitedValues;
     SmallVector<std::tuple<Value, Block *>, 8> toProcess;
 
     // Check dominance relation for proper dominance properties. If the given
     // value node does not dominate an alias, we will have to create a clone in
     // order to free all buffers that can potentially leak into a post
     // dominator.
     auto findUnsafeValues = [&](Value source, Block *definingBlock) {

mlir/lib/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.cpp

 //======- BufferViewFlowAnalysis.cpp - Buffer alias analysis -*- C++ -*-======//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.h"
 
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
 #include "llvm/ADT/SetOperations.h"
+#include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 
 /// Constructs a new alias analysis using the op provided.
 BufferViewFlowAnalysis::BufferViewFlowAnalysis(Operation *op) { build(op); }
 
 /// Find all immediate and indirect dependent buffers this value could
 /// potentially have. Note that the resulting set will also contain the value
if (result.insert(currentValue).second) {
           queue.push_back(aliasValue);
       }
     }
   }
   return result;
 }
 
 /// Removes the given values from all alias sets.
-void BufferViewFlowAnalysis::remove(const SmallPtrSetImpl<Value> &aliasValues) {
+void BufferViewFlowAnalysis::remove(const SetVector<Value> &aliasValues) {
   for (auto &entry : dependencies)
     llvm::set_subtract(entry.second, aliasValues);
 }
 
 /// This function constructs a mapping from values to its immediate
 /// dependencies. It iterates over all blocks, gets their predecessors,
 /// determines the values that will be passed to the corresponding block
 /// arguments and inserts them into the underlying map. Furthermore, it wires