Add support for processing Ops with empty region to the CSE

[Ding]

Summary

CSE pass used to not able to do CSE among ops with empty region, this commit add support for CSE to process these ops.

mlir/lib/Transforms/CSE.cpp

static bool isEqual(const Operation *lhsC, const Operation *rhsC) {
     if (lhs == rhs)
       return true;
     if (lhs == getTombstoneKey() || lhs == getEmptyKey() ||
         rhs == getTombstoneKey() || rhs == getEmptyKey())
       return false;
 
     // If op has no regions, operation equivalence w.r.t operands alone is
     // enough.
-    if (lhs->getNumRegions() == 0 && rhs->getNumRegions() == 0) {
+    if ((lhs->getNumRegions() == 0 && rhs->getNumRegions() == 0) ||
+      ((lhs->getNumRegions() == 1 && lhs->getRegion(0).empty()) &&
+      (rhs->getNumRegions() == 1 && rhs->getRegion(0).empty()))) {
       return OperationEquivalence::isEquivalentTo(
           const_cast<Operation *>(lhsC), const_cast<Operation *>(rhsC),
           OperationEquivalence::exactValueMatch,
           OperationEquivalence::ignoreValueEquivalence,
           OperationEquivalence::IgnoreLocations);
     }
 
     // If lhs or rhs does not have a single region with a single block, they
if (isOpTriviallyDead(op)) {
     ++numDCE;
     return success();
   }
 
   // Don't simplify operations with nested blocks. We don't currently model
   // equality comparisons correctly among other things. It is also unclear
   // whether we would want to CSE such operations.
   if (op->getNumRegions() != 0 &&
-      (op->getNumRegions() != 1 || !llvm::hasSingleElement(op->getRegion(0))))
+      (op->getNumRegions() != 1 || 
+      !(llvm::hasSingleElement(op->getRegion(0)) || op->getRegion(0).empty())))
     return failure();
 
   // Some simple use case of operation with memory side-effect are dealt with
   // here. Operations with no side-effect are done after.
   if (!isMemoryEffectFree(op)) {
     auto memEffects = dyn_cast<MemoryEffectOpInterface>(op);
     // TODO: Only basic use case for operations with MemoryEffects::Read can be
     // eleminated now. More work needs to be done for more complicated patterns