[FIRRTL][LowerIntrinsics] Add stat and preserve if no changes. (#6911)

include/circt/Dialect/FIRRTL/FIRRTLIntrinsics.h

@@ -236,8 +236,8 @@ public:
     (addConverter<T>(args), ...);
   }
 
-  /// Lowers all intrinsics in a module.
+  /// Lowers all intrinsics in a module.  Returns number converted or failure.
-  LogicalResult lower(FModuleOp mod, bool allowUnknownIntrinsics = false);
+  FailureOr<size_t> lower(FModuleOp mod, bool allowUnknownIntrinsics = false);
 
 private:
   template <typename T>

include/circt/Dialect/FIRRTL/Passes.td

@@ -711,6 +711,9 @@ def LowerIntrinsics : Pass<"firrtl-lower-intrinsics", "firrtl::FModuleOp"> {
     This pass lowers generic intrinsic ops to their implementation or op.
   }];
   let constructor = "circt::firrtl::createLowerIntrinsicsPass()";
+  let statistics = [
+    Statistic<"numConverted", "num-converted", "Number of intrinsic operations lowered">,
+  ];
 }
 
 def LowerOpenAggs : Pass<"firrtl-lower-open-aggs", "firrtl::CircuitOp"> {

lib/Dialect/FIRRTL/FIRRTLIntrinsics.cpp

@@ -96,8 +96,10 @@ public:
 
   IntrinsicOpConversion(MLIRContext *context,
                         const ConversionMapTy &conversions,
+                        size_t &numConversions,
                         bool allowUnknownIntrinsics = false)
       : OpConversionPattern(context), conversions(conversions),
+        numConversions(numConversions),
         allowUnknownIntrinsics(allowUnknownIntrinsics) {}
 
   LogicalResult
@@ -115,11 +117,13 @@ public:
     if (conv.check(GenericIntrinsic(op)))
       return failure();
     conv.convert(GenericIntrinsic(op), adaptor, rewriter);
+    ++numConversions;
     return success();
   }
 
 private:
   const ConversionMapTy &conversions;
+  size_t &numConversions;
   const bool allowUnknownIntrinsics;
 };
 } // namespace
@@ -128,8 +132,8 @@ private:
 // IntrinsicLowerings
 //===----------------------------------------------------------------------===//
 
-LogicalResult IntrinsicLowerings::lower(FModuleOp mod,
+FailureOr<size_t> IntrinsicLowerings::lower(FModuleOp mod,
-                                        bool allowUnknownIntrinsics) {
+                                            bool allowUnknownIntrinsics) {
 
   ConversionTarget target(*context);
 
@@ -143,10 +147,14 @@ LogicalResult IntrinsicLowerings::lower(FModuleOp mod,
     target.addIllegalOp<GenericIntrinsicOp>();
 
   RewritePatternSet patterns(context);
-  patterns.add<IntrinsicOpConversion>(context, conversions,
+  size_t count = 0;
+  patterns.add<IntrinsicOpConversion>(context, conversions, count,
                                       allowUnknownIntrinsics);
 
-  return mlir::applyPartialConversion(mod, target, std::move(patterns));
+  if (failed(mlir::applyPartialConversion(mod, target, std::move(patterns))))
+    return failure();
+
+  return count;
 }
 
 //===----------------------------------------------------------------------===//

lib/Dialect/FIRRTL/Transforms/LowerIntrinsics.cpp

@@ -43,8 +43,14 @@ LogicalResult LowerIntrinsicsPass::initialize(MLIRContext *context) {
 
 // This is the main entrypoint for the lowering pass.
 void LowerIntrinsicsPass::runOnOperation() {
-  if (failed(lowering->lower(getOperation())))
+  auto result = lowering->lower(getOperation());
+  if (failed(result))
     return signalPassFailure();
+
+  numConverted += *result;
+
+  if (*result == 0)
+    markAllAnalysesPreserved();
 }
 
 /// This is the pass constructor.