clang  16.0.0git
LoopWidening.cpp
Go to the documentation of this file.
1 //===--- LoopWidening.cpp - Widen loops -------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// This file contains functions which are used to widen loops. A loop may be
10 /// widened to approximate the exit state(s), without analyzing every
11 /// iteration. The widening is done by invalidating anything which might be
12 /// modified by the body of the loop.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #include "clang/AST/AST.h"
20 
21 using namespace clang;
22 using namespace ento;
23 using namespace clang::ast_matchers;
24 
25 const auto MatchRef = "matchref";
26 
27 /// Return the loops condition Stmt or NULL if LoopStmt is not a loop
28 static const Expr *getLoopCondition(const Stmt *LoopStmt) {
29  switch (LoopStmt->getStmtClass()) {
30  default:
31  return nullptr;
32  case Stmt::ForStmtClass:
33  return cast<ForStmt>(LoopStmt)->getCond();
34  case Stmt::WhileStmtClass:
35  return cast<WhileStmt>(LoopStmt)->getCond();
36  case Stmt::DoStmtClass:
37  return cast<DoStmt>(LoopStmt)->getCond();
38  }
39 }
40 
41 namespace clang {
42 namespace ento {
43 
45  const LocationContext *LCtx,
46  unsigned BlockCount, const Stmt *LoopStmt) {
47 
48  assert((isa<ForStmt, WhileStmt, DoStmt>(LoopStmt)));
49 
50  // Invalidate values in the current state.
51  // TODO Make this more conservative by only invalidating values that might
52  // be modified by the body of the loop.
53  // TODO Nested loops are currently widened as a result of the invalidation
54  // being so inprecise. When the invalidation is improved, the handling
55  // of nested loops will also need to be improved.
56  ASTContext &ASTCtx = LCtx->getAnalysisDeclContext()->getASTContext();
57  const StackFrameContext *STC = LCtx->getStackFrame();
58  MemRegionManager &MRMgr = PrevState->getStateManager().getRegionManager();
59  const MemRegion *Regions[] = {MRMgr.getStackLocalsRegion(STC),
60  MRMgr.getStackArgumentsRegion(STC),
61  MRMgr.getGlobalsRegion()};
63  for (auto *Region : Regions) {
64  ITraits.setTrait(Region,
66  }
67 
68  // References should not be invalidated.
69  auto Matches = match(
71  varDecl(hasType(hasCanonicalType(referenceType()))).bind(MatchRef)))),
72  *LCtx->getDecl()->getBody(), ASTCtx);
73  for (BoundNodes Match : Matches) {
74  const VarDecl *VD = Match.getNodeAs<VarDecl>(MatchRef);
75  assert(VD);
76  const VarRegion *VarMem = MRMgr.getVarRegion(VD, LCtx);
77  ITraits.setTrait(VarMem,
79  }
80 
81 
82  // 'this' pointer is not an lvalue, we should not invalidate it. If the loop
83  // is located in a method, constructor or destructor, the value of 'this'
84  // pointer should remain unchanged. Ignore static methods, since they do not
85  // have 'this' pointers.
86  const CXXMethodDecl *CXXMD = dyn_cast<CXXMethodDecl>(STC->getDecl());
87  if (CXXMD && !CXXMD->isStatic()) {
88  const CXXThisRegion *ThisR =
89  MRMgr.getCXXThisRegion(CXXMD->getThisType(), STC);
90  ITraits.setTrait(ThisR,
92  }
93 
94  return PrevState->invalidateRegions(Regions, getLoopCondition(LoopStmt),
95  BlockCount, LCtx, true, nullptr, nullptr,
96  &ITraits);
97 }
98 
99 } // end namespace ento
100 } // end namespace clang
clang::CXXMethodDecl::getThisType
QualType getThisType() const
Return the type of the this pointer.
Definition: DeclCXX.cpp:2488
clang::AnalysisDeclContext::getASTContext
ASTContext & getASTContext() const
Definition: AnalysisDeclContext.h:104
clang::ento::MemRegionManager::getStackArgumentsRegion
const StackArgumentsSpaceRegion * getStackArgumentsRegion(const StackFrameContext *STC)
getStackArgumentsRegion - Retrieve the memory region associated with function/method arguments of the...
Definition: MemRegion.cpp:872
clang::CXXMethodDecl::isStatic
bool isStatic() const
Definition: DeclCXX.cpp:2128
clang::LocationContext
It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext ...
Definition: AnalysisDeclContext.h:215
clang::LocationContext::getStackFrame
const StackFrameContext * getStackFrame() const
Definition: AnalysisDeclContext.cpp:463
clang::ast_matchers::stmt
const internal::VariadicAllOfMatcher< Stmt > stmt
Matches statements.
Definition: ASTMatchersInternal.cpp:810
clang::ast_matchers::findAll
internal::Matcher< T > findAll(const internal::Matcher< T > &Matcher)
Matches if the node or any descendant matches.
Definition: ASTMatchers.h:3489
clang::StackFrameContext
It represents a stack frame of the call stack (based on CallEvent).
Definition: AnalysisDeclContext.h:299
ASTMatchFinder.h
clang::ento::MemRegionManager::getVarRegion
const VarRegion * getVarRegion(const VarDecl *VD, const LocationContext *LC)
getVarRegion - Retrieve or create the memory region associated with a specified VarDecl and LocationC...
Definition: MemRegion.cpp:964
clang::ento::MemRegion
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:95
clang::ento::RegionAndSymbolInvalidationTraits::TK_EntireMemSpace
@ TK_EntireMemSpace
When applied to a MemSpaceRegion, indicates the entire memory space should be invalidated.
Definition: MemRegion.h:1595
clang::ast_matchers
Definition: ASTMatchers.h:98
clang::ento::MemRegionManager::getCXXThisRegion
const CXXThisRegion * getCXXThisRegion(QualType thisPointerTy, const LocationContext *LC)
getCXXThisRegion - Retrieve the [artificial] region associated with the parameter 'this'.
Definition: MemRegion.cpp:1249
getLoopCondition
static const Expr * getLoopCondition(const Stmt *LoopStmt)
Return the loops condition Stmt or NULL if LoopStmt is not a loop.
Definition: LoopWidening.cpp:28
clang::ento::RegionAndSymbolInvalidationTraits::setTrait
void setTrait(SymbolRef Sym, InvalidationKinds IK)
Definition: MemRegion.cpp:1732
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:209
clang::ento::VarRegion
Definition: MemRegion.h:940
clang::ento::getWidenedLoopState
ProgramStateRef getWidenedLoopState(ProgramStateRef PrevState, const LocationContext *LCtx, unsigned BlockCount, const Stmt *LoopStmt)
Get the states that result from widening the loop.
Definition: LoopWidening.cpp:44
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:906
ExplodedGraph.h
clang::LocationContext::getAnalysisDeclContext
LLVM_ATTRIBUTE_RETURNS_NONNULL AnalysisDeclContext * getAnalysisDeclContext() const
Definition: AnalysisDeclContext.h:244
LoopWidening.h
clang::Stmt::getStmtClass
StmtClass getStmtClass() const
Definition: Stmt.h:1169
clang::ento::MemRegionManager::getStackLocalsRegion
const StackLocalsSpaceRegion * getStackLocalsRegion(const StackFrameContext *STC)
getStackLocalsRegion - Retrieve the memory region associated with the specified stack frame.
Definition: MemRegion.cpp:859
clang::ast_matchers::hasDescendant
const internal::ArgumentAdaptingMatcherFunc< internal::HasDescendantMatcher > hasDescendant
Matches AST nodes that have descendant AST nodes that match the provided matcher.
Definition: ASTMatchersInternal.cpp:1011
clang::ento::MemRegionManager
Definition: MemRegion.h:1353
clang::Decl::getBody
virtual Stmt * getBody() const
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: DeclBase.h:1052
clang::ento::RegionAndSymbolInvalidationTraits::TK_PreserveContents
@ TK_PreserveContents
Tells that a region's contents is not changed.
Definition: MemRegion.h:1585
MatchRef
const auto MatchRef
Definition: LoopWidening.cpp:25
clang
Definition: CalledOnceCheck.h:17
clang::ast_matchers::referenceType
const AstTypeMatcher< ReferenceType > referenceType
Matches both lvalue and rvalue reference types.
Definition: ASTMatchersInternal.cpp:1053
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:71
clang::ast_matchers::match
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
Definition: ASTMatchFinder.h:312
clang::ento::CXXThisRegion
CXXThisRegion - Represents the region for the implicit 'this' parameter in a call to a C++ method.
Definition: MemRegion.h:1064
clang::ast_matchers::BoundNodes
Maps string IDs to AST nodes matched by parts of a matcher.
Definition: ASTMatchers.h:107
clang::ento::MemRegionManager::getGlobalsRegion
const GlobalsSpaceRegion * getGlobalsRegion(MemRegion::Kind K=MemRegion::GlobalInternalSpaceRegionKind, const CodeTextRegion *R=nullptr)
getGlobalsRegion - Retrieve the memory region associated with global variables.
Definition: MemRegion.cpp:885
clang::ento::RegionAndSymbolInvalidationTraits
Information about invalidation for a particular region/symbol.
Definition: MemRegion.h:1570
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::ast_matchers::varDecl
const internal::VariadicDynCastAllOfMatcher< Decl, VarDecl > varDecl
Matches variable declarations.
Definition: ASTMatchersInternal.cpp:802
clang::LocationContext::getDecl
const Decl * getDecl() const
Definition: AnalysisDeclContext.h:251
llvm::IntrusiveRefCntPtr< const ProgramState >
AST.h
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1983