Add an operator == and != to properties, use it in DuplicateFunctionElimination

[rriddle]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

3519–3521

We generally have the user define the == instead of the !=, it'd be nice to keep that consistent.

[mehdi_amini]

Use == comparator

mlir/lib/Dialect/Func/Transforms/DuplicateFunctionElimination.cpp

func.getBody().walk([&](Operation *op) {
                     op, /*hashOperands=*/OperationEquivalence::ignoreHashValue,
                     /*hashResults=*/OperationEquivalence::ignoreHashValue,
                     OperationEquivalence::IgnoreLocations));
     });
 
     return hash;
   }
 
-  static bool isEqual(const func::FuncOp cLhs, const func::FuncOp cRhs) {
-    if (cLhs == cRhs) {
+  static bool isEqual(func::FuncOp lhs, func::FuncOp rhs) {
+    if (lhs == rhs)
       return true;
-    }
-    if (cLhs == getTombstoneKey() || cLhs == getEmptyKey() ||
-        cRhs == getTombstoneKey() || cRhs == getEmptyKey()) {
+    if (lhs == getTombstoneKey() || lhs == getEmptyKey() ||
+        rhs == getTombstoneKey() || rhs == getEmptyKey())
       return false;
-    }
-
-    // Check attributes equivalence, ignoring the symbol name.
-    if (cLhs->getAttrDictionary().size() != cRhs->getAttrDictionary().size()) {
+    // Check discardable attributes equivalence
+    if (lhs->getDiscardableAttrDictionary() !=
+        rhs->getDiscardableAttrDictionary())
       return false;
-    }
-    func::FuncOp lhs = const_cast<func::FuncOp &>(cLhs);
-    StringAttr symNameAttrName = lhs.getSymNameAttrName();
-    for (NamedAttribute namedAttr : cLhs->getAttrs()) {
-      StringAttr attrName = namedAttr.getName();
-      if (attrName == symNameAttrName) {
-        continue;
-      }
-      if (namedAttr.getValue() != cRhs->getAttr(attrName)) {
-        return false;
-      }
-    }
+
+    // Check properties equivalence, ignoring the symbol name.
+    // Make a copy, so that we can erase the symbol name and perform the
+    // comparison.
+    auto pLhs = lhs.getProperties();
+    auto pRhs = rhs.getProperties();
+    pLhs.sym_name = nullptr;
+    pRhs.sym_name = nullptr;
+    if (pLhs != pRhs)
 
     // Compare inner workings.
-    func::FuncOp rhs = const_cast<func::FuncOp &>(cRhs);
     return OperationEquivalence::isRegionEquivalentTo(
         &lhs.getBody(), &rhs.getBody(), OperationEquivalence::IgnoreLocations);
   }
 };
 
 struct DuplicateFunctionEliminationPass
     : public impl::DuplicateFunctionEliminationPassBase<
           DuplicateFunctionEliminationPass> {

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp

private:
   bool onlyContainsBranchConditionalOp(Block *block) const {
     return std::next(block->begin()) == block->end() &&
            isa<spirv::BranchConditionalOp>(block->front());
   }
 
   bool isSameAttrList(spirv::StoreOp lhs, spirv::StoreOp rhs) const {
     return lhs->getDiscardableAttrDictionary() ==
                rhs->getDiscardableAttrDictionary() &&
-           lhs->hashProperties() == rhs->hashProperties();
+           lhs.getProperties() == rhs.getProperties();
   }
 
   // Returns a source value for the given block.
   Value getSrcValue(Block *block) const {
     auto storeOp = cast<spirv::StoreOp>(block->front());
     return storeOp.getValue();
   }
 

mlir/test/lib/Dialect/Test/TestDialect.h

 
 struct PropertiesWithCustomPrint {
   /// A shared_ptr to a const object is safe: it is equivalent to a value-based
   /// member. Here the label will be deallocated when the last operation
   /// refering to it is destroyed. However there is no pool-allocation: this is
   /// offloaded to the client.
   std::shared_ptr<const std::string> label;
   int value;
+  bool operator==(const PropertiesWithCustomPrint &rhs) const {
+    return value == rhs.value && *label == *rhs.label;
+  }
 };
 class MyPropStruct {
 public:
   std::string content;
   // These three methods are invoked through the  `MyStructProperty` wrapper
   // defined in TestOps.td
   mlir::Attribute asAttribute(mlir::MLIRContext *ctx) const;
   static mlir::LogicalResult setFromAttr(MyPropStruct &prop,
                                          mlir::Attribute attr,
                                          mlir::InFlightDiagnostic *diag);
   llvm::hash_code hash() const;
+  bool operator==(const MyPropStruct &rhs) const {
+    return content == rhs.content;
+  }
 };
 } // namespace test
 
 #define GET_OP_CLASSES
 #include "TestOps.h.inc"
 
 namespace test {
 

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

for (const std::pair<StringRef, AttributeMetadata> &it :
       if (!it.second.constraint || !it.second.constraint->isDerivedAttr())
         attrOrProperties.push_back(&it.second);
     }
     for (const NamedProperty &prop : op.getProperties())
       attrOrProperties.push_back(&prop);
     assert(!attrOrProperties.empty());
     std::string declarations = "  struct Properties {\n";
     llvm::raw_string_ostream os(declarations);
+    std::string comparator =
+        "    bool operator==(const Properties &rhs) const {\n"
+        "      return \n";
+    llvm::raw_string_ostream comparatorOs(comparator);
     for (const auto &attrOrProp : attrOrProperties) {
       if (const auto *namedProperty =
               attrOrProp.dyn_cast<const NamedProperty *>()) {
         StringRef name = namedProperty->name;
         if (name.empty())
           report_fatal_error("missing name for property");
         std::string camelName =
             convertToCamelFromSnakeCase(name, /*capitalizeFirst=*/true);
         auto &prop = namedProperty->prop;
         // Generate the data member using the storage type.
         os << "    using " << name << "Ty = " << prop.getStorageType() << ";\n"
            << "    " << name << "Ty " << name;
         if (prop.hasDefaultValue())
           os << " = " << prop.getDefaultValue();
-
+        comparatorOs << "        rhs." << name << " == this->" << name
+                     << " &&\n";
         // Emit accessors using the interface type.
         const char *accessorFmt = R"decl(;
     {0} get{1}() {
       auto &propStorage = this->{2};
       return {3};
     }
     void set{1}(const {0} &propValue) {
       auto &propStorage = this->{2};
)decl";
         if (name != operandSegmentAttrName && name != resultSegmentAttrName) {
           report_fatal_error("unexpected AttributeMetadata");
         }
         // TODO: update to use native integers.
         storageType = "::mlir::DenseI32ArrayAttr";
       }
       os << "    using " << name << "Ty = " << storageType << ";\n"
          << "    " << name << "Ty " << name << ";\n";
+      comparatorOs << "        rhs." << name << " == this->" << name << " &&\n";
 
       // Emit accessors using the interface type.
       if (attr) {
         const char *accessorFmt = R"decl(
     auto get{0}() {
       auto &propStorage = this->{1};
       return propStorage.{2}<{3}>();
     }
     void set{0}(const {3} &propValue) {
       this->{1} = propValue;
     }
 )decl";
         os << formatv(accessorFmt, camelName, name,
                       attr->isOptional() || attr->hasDefaultValue()
                           ? "dyn_cast_or_null"
                           : "cast",
                       storageType);
       }
     }
+    comparatorOs << "        true;\n    }\n"
+                    "    bool operator!=(const Properties &rhs) const {\n"
+                    "      return !(*this == rhs);\n"
+                    "    }\n";
+    comparatorOs.flush();
+    os << comparator;
     os << "  };\n";
     os.flush();
+
     genericAdaptorBase.declare<ExtraClassDeclaration>(std::move(declarations));
   }
   genericAdaptorBase.declare<VisibilityDeclaration>(Visibility::Protected);
   genericAdaptorBase.declare<Field>("::mlir::DictionaryAttr", "odsAttrs");
   genericAdaptorBase.declare<Field>("::std::optional<::mlir::OperationName>",
                                     "odsOpName");
   if (useProperties)
     genericAdaptorBase.declare<Field>("Properties", "properties");