EIC code displayed by LXR master/​include/​clang/​Analysis/​Analyses/​ExprMutationAnalyzer.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:36:23

 //===---------- ExprMutationAnalyzer.h ------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_EXPRMUTATIONANALYZER_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_EXPRMUTATIONANALYZER_H
 
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "llvm/ADT/DenseMap.h"
 #include <memory>
 
 namespace clang {
 
 class FunctionParmMutationAnalyzer;
 
 /// Analyzes whether any mutative operations are applied to an expression within
 /// a given statement.
 class ExprMutationAnalyzer {
   friend class FunctionParmMutationAnalyzer;
 
 public:
   struct Memoized {
     using ResultMap = llvm::DenseMap<const Expr *, const Stmt *>;
     using FunctionParaAnalyzerMap =
         llvm::SmallDenseMap<const FunctionDecl *,
                             std::unique_ptr<FunctionParmMutationAnalyzer>>;
 
     ResultMap Results;
     ResultMap PointeeResults;
     FunctionParaAnalyzerMap FuncParmAnalyzer;
 
     void clear() {
       Results.clear();
       PointeeResults.clear();
       FuncParmAnalyzer.clear();
     }
   };
   struct Analyzer {
     Analyzer(const Stmt &Stm, ASTContext &Context, Memoized &Memorized)
         : Stm(Stm), Context(Context), Memorized(Memorized) {}
 
     const Stmt *findMutation(const Expr *Exp);
     const Stmt *findMutation(const Decl *Dec);
 
     const Stmt *findPointeeMutation(const Expr *Exp);
     const Stmt *findPointeeMutation(const Decl *Dec);
 
   private:
     using MutationFinder = const Stmt *(Analyzer::*)(const Expr *);
 
     const Stmt *findMutationMemoized(const Expr *Exp,
                                      llvm::ArrayRef<MutationFinder> Finders,
                                      Memoized::ResultMap &MemoizedResults);
     const Stmt *tryEachDeclRef(const Decl *Dec, MutationFinder Finder);
 
     const Stmt *findExprMutation(ArrayRef<ast_matchers::BoundNodes> Matches);
     const Stmt *findDeclMutation(ArrayRef<ast_matchers::BoundNodes> Matches);
     const Stmt *
     findExprPointeeMutation(ArrayRef<ast_matchers::BoundNodes> Matches);
     const Stmt *
     findDeclPointeeMutation(ArrayRef<ast_matchers::BoundNodes> Matches);
 
     const Stmt *findDirectMutation(const Expr *Exp);
     const Stmt *findMemberMutation(const Expr *Exp);
     const Stmt *findArrayElementMutation(const Expr *Exp);
     const Stmt *findCastMutation(const Expr *Exp);
     const Stmt *findRangeLoopMutation(const Expr *Exp);
     const Stmt *findReferenceMutation(const Expr *Exp);
     const Stmt *findFunctionArgMutation(const Expr *Exp);
 
     const Stmt *findPointeeValueMutation(const Expr *Exp);
     const Stmt *findPointeeMemberMutation(const Expr *Exp);
     const Stmt *findPointeeToNonConst(const Expr *Exp);
 
     const Stmt &Stm;
     ASTContext &Context;
     Memoized &Memorized;
   };
 
   ExprMutationAnalyzer(const Stmt &Stm, ASTContext &Context)
       : Memorized(), A(Stm, Context, Memorized) {}
 
   /// check whether stmt is unevaluated. mutation analyzer will ignore the
   /// content in unevaluated stmt.
   static bool isUnevaluated(const Stmt *Stm, ASTContext &Context);
 
   bool isMutated(const Expr *Exp) { return findMutation(Exp) != nullptr; }
   bool isMutated(const Decl *Dec) { return findMutation(Dec) != nullptr; }
   const Stmt *findMutation(const Expr *Exp) { return A.findMutation(Exp); }
   const Stmt *findMutation(const Decl *Dec) { return A.findMutation(Dec); }
 
   bool isPointeeMutated(const Expr *Exp) {
     return findPointeeMutation(Exp) != nullptr;
   }
   bool isPointeeMutated(const Decl *Dec) {
     return findPointeeMutation(Dec) != nullptr;
   }
   const Stmt *findPointeeMutation(const Expr *Exp) {
     return A.findPointeeMutation(Exp);
   }
   const Stmt *findPointeeMutation(const Decl *Dec) {
     return A.findPointeeMutation(Dec);
   }
 
 private:
   Memoized Memorized;
   Analyzer A;
 };
 
 // A convenient wrapper around ExprMutationAnalyzer for analyzing function
 // params.
 class FunctionParmMutationAnalyzer {
 public:
   static FunctionParmMutationAnalyzer *
   getFunctionParmMutationAnalyzer(const FunctionDecl &Func, ASTContext &Context,
                                   ExprMutationAnalyzer::Memoized &Memorized) {
     auto it = Memorized.FuncParmAnalyzer.find(&Func);
     if (it == Memorized.FuncParmAnalyzer.end()) {
       // Creating a new instance of FunctionParmMutationAnalyzer below may add
       // additional elements to FuncParmAnalyzer. If we did try_emplace before
       // creating a new instance, the returned iterator of try_emplace could be
       // invalidated.
       it =
           Memorized.FuncParmAnalyzer
               .try_emplace(&Func, std::unique_ptr<FunctionParmMutationAnalyzer>(
                                       new FunctionParmMutationAnalyzer(
                                           Func, Context, Memorized)))
               .first;
     }
     return it->getSecond().get();
   }
 
   bool isMutated(const ParmVarDecl *Parm) {
     return findMutation(Parm) != nullptr;
   }
   const Stmt *findMutation(const ParmVarDecl *Parm);
 
 private:
   ExprMutationAnalyzer::Analyzer BodyAnalyzer;
   llvm::DenseMap<const ParmVarDecl *, const Stmt *> Results;
 
   FunctionParmMutationAnalyzer(const FunctionDecl &Func, ASTContext &Context,
                                ExprMutationAnalyzer::Memoized &Memorized);
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_ANALYSES_EXPRMUTATIONANALYZER_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team