Separating the StmtClassName and QualType for missing origin counts and putting them in separate maps

Author: DEBADRIBASAK

clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h

@@ -74,7 +74,6 @@ struct LifetimeFactory {
 /// Running the lifetime safety analysis and querying its results. It
 /// encapsulates the various dataflow analyses.
 class LifetimeSafetyAnalysis {
-
 public:
   LifetimeSafetyAnalysis(AnalysisDeclContext &AC,
                          LifetimeSafetyReporter *Reporter);

clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeStats.h

@@ -1,16 +1,15 @@
-//===- LifetimeStats.h - Miscellaneous statistics related to lifetime safety
-//analysis ---*- C++ -*-===//
+//===- LifetimeStats.h - Lifetime Safety Statistics --------------*- 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
 //
-//===----------------------------------------------------------------------------------------------===//
+//===------------------------------------------------------------------------===//
 //
 // This file declares the data structures and utility function for collection of
-// staticstics related to Lifetimesafety analysis.
+// statistics related to Lifetime Safety analysis.
 //
-//===----------------------------------------------------------------------------------------------===//
+//===------------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIFETIMESTATS_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIFETIMESTATS_H
@@ -19,15 +18,17 @@
 
 namespace clang::lifetimes {
 /// A structure to hold the statistics related to LifetimeAnalysis.
-/// Currently it holds only the missing origin details.
+/// These are accumulated across all analyzed functions and printed
+/// when -print-stats is enabled.
 struct LifetimeSafetyStats {
-  /// A map from `ExpressionClassName<QualType>` to their missing origin
-  /// counts.
-  llvm::StringMap<unsigned> MissingOriginCount;
+  /// A map from `QualType` to their missing origin counts.
+  llvm::StringMap<unsigned> ExprStmtClassToMissingOriginCount;
+  /// A map from `StmtClassName` to their missing origin counts.
+  llvm::StringMap<unsigned> ExprTypeToMissingOriginCount;
 };
 
-// utility function to print missing origin stats.
+/// Utility function to print missing origin stats.
 void printStats(const LifetimeSafetyStats &Stats);
 } // namespace clang::lifetimes
 
-#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIFETIMESTATS_H
+#endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIFETIMESTATS_H

clang/lib/Analysis/LifetimeSafety/LifetimeStats.cpp

@@ -1,5 +1,4 @@
-//===- LifetimeStats.cpp - Miscellaneous statistics related to C++ Lifetime
-//Safety analysis -*--------- C++-*-===//
+//===- LifetimeStats.cpp - Lifetime Safety Statistics -*------------ C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -17,14 +16,19 @@
 
 namespace clang::lifetimes {
 void printStats(const LifetimeSafetyStats &Stats) {
-  llvm::errs() << "\n*** LifetimeSafety Missing Origin Stats "
-                  "(expression_type : count) :\n\n";
+  llvm::errs() << "\n*** LifetimeSafety Missing Origin per QualType: "
+                  "(QualType : count) :\n\n";
   unsigned TotalMissingOrigins = 0;
-  for (const auto &[expr, count] : Stats.MissingOriginCount) {
-    llvm::errs() << expr << " : " << count << '\n';
+  for (const auto &[type, count] : Stats.ExprTypeToMissingOriginCount) {
+    llvm::errs() << type << " : " << count << '\n';
     TotalMissingOrigins += count;
   }
-  llvm::errs() << "Total missing origins: " << TotalMissingOrigins << "\n";
+  llvm::errs() << "\n\n*** LifetimeSafety Missing Origin per StmtClassName: "
+                  "(StmtClassName : count) :\n\n";
+  for (const auto &[stmt, count] : Stats.ExprStmtClassToMissingOriginCount) {
+    llvm::errs() << stmt << " : " << count << '\n';
+  }
+  llvm::errs() << "\nTotal missing origins: " << TotalMissingOrigins << "\n";
   llvm::errs() << "\n****************************************\n";
 }
-} // namespace clang::lifetimes
+} // namespace clang::lifetimes

clang/lib/Analysis/LifetimeSafety/Origins.cpp

@@ -23,33 +23,34 @@ bool isPointerType(QualType QT) {
 bool hasOrigin(const Expr *E) {
   return E->isGLValue() || isPointerType(E->getType());
 }
-/// An utility class to traverse the function body in the analysis
+/// A utility class to traverse the function body in the analysis
 /// context and collect the count of expressions with missing origins.
 class MissingOriginCollector
     : public RecursiveASTVisitor<MissingOriginCollector> {
 public:
   MissingOriginCollector(
       const llvm::DenseMap<const clang::Expr *, OriginID> &ExprToOriginId,
-      llvm::StringMap<unsigned> &MissingOriginCount)
-      : ExprToOriginId(ExprToOriginId), MissingOriginCount(MissingOriginCount) {
-  }
+      llvm::StringMap<unsigned> &ExprStmtClassToMissingOriginCount,
+      llvm::StringMap<unsigned> &ExprTypeToMissingOriginCount)
+      : ExprToOriginId(ExprToOriginId),
+        ExprStmtClassToMissingOriginCount(ExprStmtClassToMissingOriginCount),
+        ExprTypeToMissingOriginCount(ExprTypeToMissingOriginCount) {}
   bool VisitExpr(Expr *E) {
     if (!hasOrigin(E))
       return true;
     // Check if we have an origin for this expression.
-    auto It = this->ExprToOriginId.find(E);
-    if (It == this->ExprToOriginId.end()) {
+    if (!ExprToOriginId.contains(E)) {
       // No origin found: count this as missing origin.
-      std::string ExprStr = std::string(E->getStmtClassName()) +
-                            " (Type: " + E->getType().getAsString() + ")";
-      MissingOriginCount[ExprStr]++;
+      ExprTypeToMissingOriginCount[std::string(E->getType().getAsString())]++;
+      ExprStmtClassToMissingOriginCount[std::string(E->getStmtClassName())]++;
     }
     return true;
   }
 
 private:
   const llvm::DenseMap<const clang::Expr *, OriginID> &ExprToOriginId;
-  llvm::StringMap<unsigned> &MissingOriginCount;
+  llvm::StringMap<unsigned> &ExprStmtClassToMissingOriginCount;
+  llvm::StringMap<unsigned> &ExprTypeToMissingOriginCount;
 };
 } // namespace
 
@@ -137,7 +138,8 @@ void OriginManager::collectMissingOrigins(Stmt *FunctionBody,
     return;
 
   MissingOriginCollector Collector(this->ExprToOriginID,
-                                   LSStats.MissingOriginCount);
+                                   LSStats.ExprStmtClassToMissingOriginCount,
+                                   LSStats.ExprTypeToMissingOriginCount);
   Collector.TraverseStmt(const_cast<Stmt *>(FunctionBody));
 }
 

clang/lib/Sema/AnalysisBasedWarnings.cpp

@@ -47,12 +47,12 @@
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <deque>
 #include <iterator>