move dataflow to lib

Author: usx95

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

@@ -15,18 +15,17 @@
 #define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_CHECKER_H
 
 #include "clang/Analysis/Analyses/LifetimeSafety/Facts.h"
+#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h"
 #include "clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h"
 #include "clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h"
-#include "clang/Analysis/Analyses/LifetimeSafety/Reporter.h"
 
 namespace clang::lifetimes::internal {
 
 /// Runs the lifetime checker, which detects use-after-free errors by
 /// examining loan expiration points and checking if any live origins hold
 /// the expired loan.
-void runLifetimeChecker(LoanPropagationAnalysis &LoanPropagation,
-                        LiveOriginAnalysis &LiveOrigins, FactManager &FactMgr,
-                        AnalysisDeclContext &ADC,
+void runLifetimeChecker(const LoanPropagation &LP, const LiveOrigins &LO,
+                        const FactManager &FactMgr, AnalysisDeclContext &ADC,
                         LifetimeSafetyReporter *Reporter);
 
 } // namespace clang::lifetimes::internal

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

@@ -12,8 +12,7 @@
 
 #include "clang/AST/DeclCXX.h"
 
-namespace clang {
-namespace lifetimes {
+namespace clang ::lifetimes {
 
 /// Returns the most recent declaration of the method to ensure all
 /// lifetime-bound attributes from redeclarations are considered.
@@ -38,7 +37,7 @@ bool isAssignmentOperatorLifetimeBound(const CXXMethodDecl *CMD);
 /// lifetimebound, either due to an explicit lifetimebound attribute on the
 /// method or because it's a normal assignment operator.
 bool implicitObjectParamIsLifetimeBound(const FunctionDecl *FD);
-} // namespace lifetimes
-} // namespace clang
+
+} // namespace clang::lifetimes
 
 #endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMEANNOTATIONS_H

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

@@ -21,13 +21,29 @@
 #include "clang/Analysis/Analyses/LifetimeSafety/Facts.h"
 #include "clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h"
 #include "clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h"
-#include "clang/Analysis/Analyses/LifetimeSafety/Reporter.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "llvm/ADT/StringMap.h"
 
 namespace clang::lifetimes {
 
+/// Enum to track the confidence level of a potential error.
+enum class Confidence : uint8_t {
+  None,
+  Maybe,   // Reported as a potential error (-Wlifetime-safety-strict)
+  Definite // Reported as a definite error (-Wlifetime-safety-permissive)
+};
+
+class LifetimeSafetyReporter {
+public:
+  LifetimeSafetyReporter() = default;
+  virtual ~LifetimeSafetyReporter() = default;
+
+  virtual void reportUseAfterFree(const Expr *IssueExpr, const Expr *UseExpr,
+                                  SourceLocation FreeLoc,
+                                  Confidence Confidence) {}
+};
+
 /// The main entry point for the analysis.
 void runLifetimeSafetyAnalysis(AnalysisDeclContext &AC,
                                LifetimeSafetyReporter *Reporter);
@@ -36,10 +52,10 @@ namespace internal {
 /// An object to hold the factories for immutable collections, ensuring
 /// that all created states share the same underlying memory management.
 struct LifetimeFactory {
-  llvm::BumpPtrAllocator Allocator;
-  OriginLoanMap::Factory OriginMapFactory{Allocator, /*canonicalize=*/false};
-  LoanSet::Factory LoanSetFactory{Allocator, /*canonicalize=*/false};
-  LivenessMap::Factory LivenessMapFactory{Allocator, /*canonicalize=*/false};
+  // llvm::BumpPtrAllocator Allocator;
+  OriginLoanMap::Factory OriginMapFactory{/*canonicalize=*/false};
+  LoanSet::Factory LoanSetFactory{/*canonicalize=*/false};
+  LivenessMap::Factory LivenessMapFactory{/*canonicalize=*/false};
 };
 
 /// Running the lifetime safety analysis and querying its results. It
@@ -48,22 +64,21 @@ class LifetimeSafetyAnalysis {
 public:
   LifetimeSafetyAnalysis(AnalysisDeclContext &AC,
                          LifetimeSafetyReporter *Reporter);
-  ~LifetimeSafetyAnalysis();
 
   void run();
 
   /// Returns the loan propagation analysis object.
   /// \note This is intended for testing only.
-  LoanPropagationAnalysis &getLoanPropagationAnalysis() const {
-    assert(LoanPropagation && "Analysis has not been run.");
-    return *LoanPropagation;
+  LoanPropagation &getLoanPropagation() const {
+    assert(LP && "Analysis has not been run.");
+    return *LP;
   }
 
   /// Returns the live origin analysis object.
   /// \note This is intended for testing only.
-  LiveOriginAnalysis &getLiveOriginAnalysis() const {
-    assert(LiveOrigins && "Analysis has not been run.");
-    return *LiveOrigins;
+  LiveOrigins &getLiveOriginAnalysis() const {
+    assert(LO && "Analysis has not been run.");
+    return *LO;
   }
 
   /// Returns the set of origins that are live at a specific program point,
@@ -101,8 +116,8 @@ class LifetimeSafetyAnalysis {
   LifetimeSafetyReporter *Reporter;
   LifetimeFactory Factory;
   FactManager FactMgr;
-  std::unique_ptr<LoanPropagationAnalysis> LoanPropagation;
-  std::unique_ptr<LiveOriginAnalysis> LiveOrigins;
+  std::unique_ptr<LiveOrigins> LO;
+  std::unique_ptr<LoanPropagation> LP;
 };
 } // namespace internal
 } // namespace clang::lifetimes

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

@@ -20,7 +20,6 @@
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIVE_ORIGINS_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIVE_ORIGINS_H
 
-#include "clang/Analysis/Analyses/LifetimeSafety/Dataflow.h"
 #include "clang/Analysis/Analyses/LifetimeSafety/Facts.h"
 #include "clang/Analysis/Analyses/LifetimeSafety/Origins.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
@@ -31,8 +30,6 @@
 
 namespace clang::lifetimes::internal {
 
-using OriginSet = llvm::ImmutableSet<OriginID>;
-
 enum class LivenessKind : uint8_t {
   Dead,  // Not alive
   Maybe, // Live on some path but not all paths (may-be-live)
@@ -45,6 +42,7 @@ struct LivenessInfo {
   /// multiple uses along different paths, this will point to the use appearing
   /// earlier in the translation unit.
   /// This is 'null' when the origin is not live.
+
   const UseFact *CausingUseFact;
   /// The kind of liveness of the origin.
   /// `Must`: The origin is live on all control-flow paths from the current
@@ -74,63 +72,22 @@ struct LivenessInfo {
 
 using LivenessMap = llvm::ImmutableMap<OriginID, LivenessInfo>;
 
-/// The dataflow lattice for origin liveness analysis.
-/// It tracks which origins are live, why they're live (which UseFact),
-/// and the confidence level of that liveness.
-struct LivenessLattice {
-  LivenessMap LiveOrigins;
-
-  LivenessLattice() : LiveOrigins(nullptr) {};
-
-  explicit LivenessLattice(LivenessMap L) : LiveOrigins(L) {}
-
-  bool operator==(const LivenessLattice &Other) const {
-    return LiveOrigins == Other.LiveOrigins;
-  }
-
-  bool operator!=(const LivenessLattice &Other) const {
-    return !(*this == Other);
-  }
-
-  void dump(llvm::raw_ostream &OS, const OriginManager &OM) const;
-};
-
-/// The analysis that tracks which origins are live, with granular information
-/// about the causing use fact and confidence level. This is a backward
-/// analysis.
-class LiveOriginAnalysis
-    : public DataflowAnalysis<LiveOriginAnalysis, LivenessLattice,
-                              Direction::Backward> {
-
+class LiveOrigins {
 public:
-  LiveOriginAnalysis(const CFG &C, AnalysisDeclContext &AC, FactManager &F,
-                     LivenessMap::Factory &SF)
-      : DataflowAnalysis(C, AC, F), FactMgr(F), Factory(SF) {}
-  using DataflowAnalysis<LiveOriginAnalysis, Lattice,
-                         Direction::Backward>::transfer;
-
-  StringRef getAnalysisName() const { return "LiveOrigins"; }
-
-  Lattice getInitialState() { return Lattice(Factory.getEmptyMap()); }
-
-  Lattice join(Lattice L1, Lattice L2) const;
-
-  Lattice transfer(Lattice In, const UseFact &UF);
-  Lattice transfer(Lattice In, const IssueFact &IF);
-  Lattice transfer(Lattice In, const OriginFlowFact &OF);
-
-  LivenessMap getLiveOrigins(ProgramPoint P) const {
-    return getState(P).LiveOrigins;
-  }
+  LiveOrigins(const CFG &C, AnalysisDeclContext &AC, FactManager &F,
+              LivenessMap::Factory &SF);
+  ~LiveOrigins();
 
+  LivenessMap getLiveOrigins(ProgramPoint P) const;
   // Dump liveness values on all test points in the program.
   void dump(llvm::raw_ostream &OS,
             llvm::StringMap<ProgramPoint> TestPoints) const;
 
 private:
-  FactManager &FactMgr;
-  LivenessMap::Factory &Factory;
+  class Impl;
+  std::unique_ptr<Impl> PImpl;
 };
+
 } // namespace clang::lifetimes::internal
 
 #endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LIVE_ORIGINS_H

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

@@ -15,13 +15,11 @@
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LOAN_PROPAGATION_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LOAN_PROPAGATION_H
 
-#include "clang/Analysis/Analyses/LifetimeSafety/Dataflow.h"
 #include "clang/Analysis/Analyses/LifetimeSafety/Facts.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "llvm/ADT/ImmutableMap.h"
 #include "llvm/ADT/ImmutableSet.h"
-#include "llvm/Support/Debug.h"
 
 namespace clang::lifetimes::internal {
 
@@ -31,65 +29,22 @@ namespace clang::lifetimes::internal {
 using LoanSet = llvm::ImmutableSet<LoanID>;
 using OriginLoanMap = llvm::ImmutableMap<OriginID, LoanSet>;
 
-/// Represents the dataflow lattice for loan propagation.
-///
-/// This lattice tracks which loans each origin may hold at a given program
-/// point.The lattice has a finite height: An origin's loan set is bounded by
-/// the total number of loans in the function.
-/// TODO(opt): To reduce the lattice size, propagate origins of declarations,
-/// not expressions, because expressions are not visible across blocks.
-struct LoanPropagationLattice {
-  /// The map from an origin to the set of loans it contains.
-  OriginLoanMap Origins = OriginLoanMap(nullptr);
-
-  explicit LoanPropagationLattice(const OriginLoanMap &S) : Origins(S) {}
-  LoanPropagationLattice() = default;
-
-  bool operator==(const LoanPropagationLattice &Other) const {
-    return Origins == Other.Origins;
-  }
-  bool operator!=(const LoanPropagationLattice &Other) const {
-    return !(*this == Other);
-  }
-
-  void dump(llvm::raw_ostream &OS) const;
-};
-
-class LoanPropagationAnalysis
-    : public DataflowAnalysis<LoanPropagationAnalysis, LoanPropagationLattice,
-                              Direction::Forward> {
-  OriginLoanMap::Factory &OriginLoanMapFactory;
-  LoanSet::Factory &LoanSetFactory;
-
+class LoanPropagation {
 public:
-  LoanPropagationAnalysis(const CFG &C, AnalysisDeclContext &AC, FactManager &F,
-                          OriginLoanMap::Factory &OriginLoanMapFactory,
-                          LoanSet::Factory &LoanSetFactory)
-      : DataflowAnalysis(C, AC, F), OriginLoanMapFactory(OriginLoanMapFactory),
-        LoanSetFactory(LoanSetFactory) {}
-
-  using Base::transfer;
+  LoanPropagation(const CFG &C, AnalysisDeclContext &AC, FactManager &F,
+                  OriginLoanMap::Factory &OriginLoanMapFactory,
+                  LoanSet::Factory &LoanSetFactory);
+  ~LoanPropagation();
 
-  StringRef getAnalysisName() const { return "LoanPropagation"; }
-
-  Lattice getInitialState() { return Lattice{}; }
-
-  Lattice join(Lattice A, Lattice B);
-
-  Lattice transfer(Lattice In, const IssueFact &F);
-  Lattice transfer(Lattice In, const OriginFlowFact &F);
-
-  LoanSet getLoans(OriginID OID, ProgramPoint P) const {
-    return getLoans(getState(P), OID);
-  }
+  LoanSet getLoans(OriginID OID, ProgramPoint P) const;
 
 private:
-  LoanSet getLoans(Lattice L, OriginID OID) const {
-    if (auto *Loans = L.Origins.lookup(OID))
-      return *Loans;
-    return LoanSetFactory.getEmptySet();
-  }
+  class Impl;
+
+public:
+  std::unique_ptr<Impl> PImpl;
 };
+
 } // namespace clang::lifetimes::internal
 
 #endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_LOAN_PROPAGATION_H

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

@@ -21,6 +21,7 @@
 namespace clang::lifetimes::internal {
 
 using OriginID = utils::ID<struct OriginTag>;
+
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, OriginID ID) {
   return OS << ID.Value;
 }