[mlir-tblgen] Fix non-deterministic generating static verifier in DRR.

[Chia-hungDuan]

Summary

Use SetVector instead of DenseSet to ensure we always generate the same
name for the same function. This issue is found in
https://github.com/llvm/llvm-project/issues/53768.

[rdzhabarov]

mlir/include/mlir/TableGen/CodeGenHelpers.h

117

Just pass ArrayRef by value (here and other places)

[Chia-hungDuan]

Address review comment

[Chia-hungDuan]

Thanks for the review. Will wait for @quinnp's verification

mlir/include/mlir/TableGen/CodeGenHelpers.h

117

Done.

[quinnp]

LGTM. @Chia-hungDuan I've verified that this fixes the issue. Thanks again for implementing this!

mlir/include/mlir/TableGen/CodeGenHelpers.h

public:
   /// `$_self` and `$_op` are not uniqued.
   void emitOpConstraints(ArrayRef<llvm::Record *> opDefs, bool emitDecl);
 
   /// Unique all compatible type and attribute constraints from a pattern file
   /// and emit them at the top of the generated file.
   ///
   /// Constraints that do not meet the restriction that they can only reference
   /// `$_self`, `$_op`, and `$_builder` are not uniqued.
-  void emitPatternConstraints(const DenseSet<DagLeaf> &constraints);
+  void emitPatternConstraints(const ArrayRef<DagLeaf> constraints);
 
   /// Get the name of the static function used for the given type constraint.
   /// These functions are used for operand and result constraints and have the
   /// form:
   ///
   ///   LogicalResult(Operation *op, Type type, StringRef valueKind,
   ///                 unsigned valueIndex);
   ///
private:
   void emitRegionConstraints();
 
   /// Emit pattern constraints.
   void emitPatternConstraints();
 
   /// Collect and unique all the constraints used by operations.
   void collectOpConstraints(ArrayRef<llvm::Record *> opDefs);
   /// Collect and unique all pattern constraints.
-  void collectPatternConstraints(const DenseSet<DagLeaf> &constraints);
+  void collectPatternConstraints(ArrayRef<DagLeaf> constraints);
 
   /// The output stream.
   raw_ostream &os;
 
   /// A unique label for the file currently being generated. This is used to
   /// ensure that the static functions have a unique name.
   std::string uniqueOutputLabel;
 

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

void StaticVerifierFunctionEmitter::emitOpConstraints(
   NamespaceEmitter namespaceEmitter(os, Operator(*opDefs[0]).getCppNamespace());
   emitTypeConstraints();
   emitAttrConstraints();
   emitSuccessorConstraints();
   emitRegionConstraints();
 }
 
 void StaticVerifierFunctionEmitter::emitPatternConstraints(
-    const llvm::DenseSet<DagLeaf> &constraints) {
+    const llvm::ArrayRef<DagLeaf> constraints) {
   collectPatternConstraints(constraints);
   emitPatternConstraints();
 }
 
 //===----------------------------------------------------------------------===//
 // Constraint Getters
 
 StringRef StaticVerifierFunctionEmitter::getTypeConstraintFn(
for (Record *def : opDefs) {
     /// Collect region constraints.
     for (const NamedRegion &region : op.getRegions())
       if (!region.constraint.getPredicate().isNull())
         collectConstraint(regionConstraints, "region", region.constraint);
   }
 }
 
 void StaticVerifierFunctionEmitter::collectPatternConstraints(
-    const llvm::DenseSet<DagLeaf> &constraints) {
+    const llvm::ArrayRef<DagLeaf> constraints) {
   for (auto &leaf : constraints) {
     assert(leaf.isOperandMatcher() || leaf.isAttrMatcher());
     collectConstraint(
         leaf.isOperandMatcher() ? typeConstraints : attrConstraints,
         leaf.isOperandMatcher() ? "type" : "attr", leaf.getAsConstraint());
   }
 }
 

mlir/tools/mlir-tblgen/RewriterGen.cpp

private:
   // DagNode while the number of users exceeds a certain threshold.
   DenseMap<DagNode, unsigned> refStats;
 
   // Number of static matcher generated. This is used to generate a unique name
   // for each DagNode.
   int staticMatcherCounter = 0;
 
   // The DagLeaf which contains type or attr constraint.
-  DenseSet<DagLeaf> constraints;
+  SetVector<DagLeaf> constraints;
 
   // Static type/attribute verification function emitter.
   StaticVerifierFunctionEmitter staticVerifierEmitter;
 };
 
 } // namespace
 
 PatternEmitter::PatternEmitter(Record *pat, RecordOperatorMap *mapper,
for (auto &dagInfo : topologicalOrder) {
     assert(matcherNames.find(node) == matcherNames.end());
     PatternEmitter(dagInfo.second, &opMap, os, *this)
         .emitStaticMatcher(node, funcName);
     matcherNames[node] = funcName;
   }
 }
 
 void StaticMatcherHelper::populateStaticConstraintFunctions(raw_ostream &os) {
-  staticVerifierEmitter.emitPatternConstraints(constraints);
+  staticVerifierEmitter.emitPatternConstraints(constraints.getArrayRef());
 }
 
 void StaticMatcherHelper::addPattern(Record *record) {
   Pattern pat(record, &opMap);
 
   // While generating the function body of the DAG matcher, it may depends on
   // other DAG matchers. To ensure the dependent matchers are ready, we compute
   // the topological order for all the DAGs and emit the DAG matchers in this