1 //===--- LoopUnrolling.cpp - Unroll loops -----------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// This file contains functions which are used to decide if a loop worth to be
11 /// unrolled. Moreover, these functions manages the stack of loop which is
12 /// tracked by the ProgramState.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #include "clang/ASTMatchers/ASTMatchers.h"
17 #include "clang/ASTMatchers/ASTMatchFinder.h"
18 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
19 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
20 #include "clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h"
21 
22 using namespace clang;
23 using namespace ento;
24 using namespace clang::ast_matchers;
25 
26 static const int MAXIMUM_STEP_UNROLLED = 128;
27 
28 struct LoopState {
29 private:
30   enum Kind { Normal, Unrolled } K;
31   const Stmt *LoopStmt;
32   const LocationContext *LCtx;
33   unsigned maxStep;
34   LoopState(Kind InK, const Stmt *S, const LocationContext *L, unsigned N)
35       : K(InK), LoopStmt(S), LCtx(L), maxStep(N) {}
36 
37 public:
38   static LoopState getNormal(const Stmt *S, const LocationContext *L,
39                              unsigned N) {
40     return LoopState(Normal, S, L, N);
41   }
42   static LoopState getUnrolled(const Stmt *S, const LocationContext *L,
43                                unsigned N) {
44     return LoopState(Unrolled, S, L, N);
45   }
46   bool isUnrolled() const { return K == Unrolled; }
47   unsigned getMaxStep() const { return maxStep; }
48   const Stmt *getLoopStmt() const { return LoopStmt; }
49   const LocationContext *getLocationContext() const { return LCtx; }
50   bool operator==(const LoopState &X) const {
51     return K == X.K && LoopStmt == X.LoopStmt;
52   }
53   void Profile(llvm::FoldingSetNodeID &ID) const {
54     ID.AddInteger(K);
55     ID.AddPointer(LoopStmt);
56     ID.AddPointer(LCtx);
57     ID.AddInteger(maxStep);
58   }
59 };
60 
61 // The tracked stack of loops. The stack indicates that which loops the
62 // simulated element contained by. The loops are marked depending if we decided
63 // to unroll them.
64 // TODO: The loop stack should not need to be in the program state since it is
65 // lexical in nature. Instead, the stack of loops should be tracked in the
66 // LocationContext.
67 REGISTER_LIST_WITH_PROGRAMSTATE(LoopStack, LoopState)
68 
69 namespace clang {
70 namespace ento {
71 
72 static bool isLoopStmt(const Stmt *S) {
73   return S && (isa<ForStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S));
74 }
75 
76 ProgramStateRef processLoopEnd(const Stmt *LoopStmt, ProgramStateRef State) {
77   auto LS = State->get<LoopStack>();
78   if (!LS.isEmpty() && LS.getHead().getLoopStmt() == LoopStmt)
79     State = State->set<LoopStack>(LS.getTail());
80   return State;
81 }
82 
83 static internal::Matcher<Stmt> simpleCondition(StringRef BindName) {
84   return binaryOperator(anyOf(hasOperatorName("<"), hasOperatorName(">"),
85                               hasOperatorName("<="), hasOperatorName(">="),
86                               hasOperatorName("!=")),
87                         hasEitherOperand(ignoringParenImpCasts(declRefExpr(
88                             to(varDecl(hasType(isInteger())).bind(BindName))))),
89                         hasEitherOperand(ignoringParenImpCasts(
90                             integerLiteral().bind("boundNum"))))
91       .bind("conditionOperator");
92 }
93 
94 static internal::Matcher<Stmt>
95 changeIntBoundNode(internal::Matcher<Decl> VarNodeMatcher) {
96   return anyOf(
97       unaryOperator(anyOf(hasOperatorName("--"), hasOperatorName("++")),
98                     hasUnaryOperand(ignoringParenImpCasts(
99                         declRefExpr(to(varDecl(VarNodeMatcher)))))),
100       binaryOperator(isAssignmentOperator(),
101                      hasLHS(ignoringParenImpCasts(
102                          declRefExpr(to(varDecl(VarNodeMatcher)))))));
103 }
104 
105 static internal::Matcher<Stmt>
106 callByRef(internal::Matcher<Decl> VarNodeMatcher) {
107   return callExpr(forEachArgumentWithParam(
108       declRefExpr(to(varDecl(VarNodeMatcher))),
109       parmVarDecl(hasType(references(qualType(unless(isConstQualified())))))));
110 }
111 
112 static internal::Matcher<Stmt>
113 assignedToRef(internal::Matcher<Decl> VarNodeMatcher) {
114   return declStmt(hasDescendant(varDecl(
115       allOf(hasType(referenceType()),
116             hasInitializer(anyOf(
117                 initListExpr(has(declRefExpr(to(varDecl(VarNodeMatcher))))),
118                 declRefExpr(to(varDecl(VarNodeMatcher)))))))));
119 }
120 
121 static internal::Matcher<Stmt>
122 getAddrTo(internal::Matcher<Decl> VarNodeMatcher) {
123   return unaryOperator(
124       hasOperatorName("&"),
125       hasUnaryOperand(declRefExpr(hasDeclaration(VarNodeMatcher))));
126 }
127 
128 static internal::Matcher<Stmt> hasSuspiciousStmt(StringRef NodeName) {
129   return hasDescendant(stmt(
130       anyOf(gotoStmt(), switchStmt(), returnStmt(),
131             // Escaping and not known mutation of the loop counter is handled
132             // by exclusion of assigning and address-of operators and
133             // pass-by-ref function calls on the loop counter from the body.
134             changeIntBoundNode(equalsBoundNode(NodeName)),
135             callByRef(equalsBoundNode(NodeName)),
136             getAddrTo(equalsBoundNode(NodeName)),
137             assignedToRef(equalsBoundNode(NodeName)))));
138 }
139 
140 static internal::Matcher<Stmt> forLoopMatcher() {
141   return forStmt(
142              hasCondition(simpleCondition("initVarName")),
143              // Initialization should match the form: 'int i = 6' or 'i = 42'.
144              hasLoopInit(anyOf(
145                  declStmt(hasSingleDecl(varDecl(
146                      allOf(hasInitializer(integerLiteral().bind("initNum")),
147                            equalsBoundNode("initVarName"))))),
148                  binaryOperator(hasLHS(declRefExpr(to(
149                                     varDecl(equalsBoundNode("initVarName"))))),
150                                 hasRHS(integerLiteral().bind("initNum"))))),
151              // Incrementation should be a simple increment or decrement
152              // operator call.
153              hasIncrement(unaryOperator(
154                  anyOf(hasOperatorName("++"), hasOperatorName("--")),
155                  hasUnaryOperand(declRefExpr(
156                      to(varDecl(allOf(equalsBoundNode("initVarName"),
157                                       hasType(isInteger())))))))),
158              unless(hasBody(hasSuspiciousStmt("initVarName")))).bind("forLoop");
159 }
160 
161 static bool isPossiblyEscaped(const VarDecl *VD, ExplodedNode *N) {
162   // Global variables assumed as escaped variables.
163   if (VD->hasGlobalStorage())
164     return true;
165 
166   while (!N->pred_empty()) {
167     const Stmt *S = PathDiagnosticLocation::getStmt(N);
168     if (!S) {
169       N = N->getFirstPred();
170       continue;
171     }
172 
173     if (const DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
174       for (const Decl *D : DS->decls()) {
175         // Once we reach the declaration of the VD we can return.
176         if (D->getCanonicalDecl() == VD)
177           return false;
178       }
179     }
180     // Check the usage of the pass-by-ref function calls and adress-of operator
181     // on VD and reference initialized by VD.
182     ASTContext &ASTCtx =
183         N->getLocationContext()->getAnalysisDeclContext()->getASTContext();
184     auto Match =
185         match(stmt(anyOf(callByRef(equalsNode(VD)), getAddrTo(equalsNode(VD)),
186                          assignedToRef(equalsNode(VD)))),
187               *S, ASTCtx);
188     if (!Match.empty())
189       return true;
190 
191     N = N->getFirstPred();
192   }
193   llvm_unreachable("Reached root without finding the declaration of VD");
194 }
195 
196 bool shouldCompletelyUnroll(const Stmt *LoopStmt, ASTContext &ASTCtx,
197                             ExplodedNode *Pred, unsigned &maxStep) {
198 
199   if (!isLoopStmt(LoopStmt))
200     return false;
201 
202   // TODO: Match the cases where the bound is not a concrete literal but an
203   // integer with known value
204   auto Matches = match(forLoopMatcher(), *LoopStmt, ASTCtx);
205   if (Matches.empty())
206     return false;
207 
208   auto CounterVar = Matches[0].getNodeAs<VarDecl>("initVarName");
209   llvm::APInt BoundNum =
210       Matches[0].getNodeAs<IntegerLiteral>("boundNum")->getValue();
211   llvm::APInt InitNum =
212       Matches[0].getNodeAs<IntegerLiteral>("initNum")->getValue();
213   auto CondOp = Matches[0].getNodeAs<BinaryOperator>("conditionOperator");
214   if (InitNum.getBitWidth() != BoundNum.getBitWidth()) {
215     InitNum = InitNum.zextOrSelf(BoundNum.getBitWidth());
216     BoundNum = BoundNum.zextOrSelf(InitNum.getBitWidth());
217   }
218 
219   if (CondOp->getOpcode() == BO_GE || CondOp->getOpcode() == BO_LE)
220     maxStep = (BoundNum - InitNum + 1).abs().getZExtValue();
221   else
222     maxStep = (BoundNum - InitNum).abs().getZExtValue();
223 
224   // Check if the counter of the loop is not escaped before.
225   return !isPossiblyEscaped(CounterVar->getCanonicalDecl(), Pred);
226 }
227 
228 bool madeNewBranch(ExplodedNode *N, const Stmt *LoopStmt) {
229   const Stmt *S = nullptr;
230   while (!N->pred_empty()) {
231     if (N->succ_size() > 1)
232       return true;
233 
234     ProgramPoint P = N->getLocation();
235     if (Optional<BlockEntrance> BE = P.getAs<BlockEntrance>())
236       S = BE->getBlock()->getTerminator();
237 
238     if (S == LoopStmt)
239       return false;
240 
241     N = N->getFirstPred();
242   }
243 
244   llvm_unreachable("Reached root without encountering the previous step");
245 }
246 
247 // updateLoopStack is called on every basic block, therefore it needs to be fast
248 ProgramStateRef updateLoopStack(const Stmt *LoopStmt, ASTContext &ASTCtx,
249                                 ExplodedNode *Pred, unsigned maxVisitOnPath) {
250   auto State = Pred->getState();
251   auto LCtx = Pred->getLocationContext();
252 
253   if (!isLoopStmt(LoopStmt))
254     return State;
255 
256   auto LS = State->get<LoopStack>();
257   if (!LS.isEmpty() && LoopStmt == LS.getHead().getLoopStmt() &&
258       LCtx == LS.getHead().getLocationContext()) {
259     if (LS.getHead().isUnrolled() && madeNewBranch(Pred, LoopStmt)) {
260       State = State->set<LoopStack>(LS.getTail());
261       State = State->add<LoopStack>(
262           LoopState::getNormal(LoopStmt, LCtx, maxVisitOnPath));
263     }
264     return State;
265   }
266   unsigned maxStep;
267   if (!shouldCompletelyUnroll(LoopStmt, ASTCtx, Pred, maxStep)) {
268     State = State->add<LoopStack>(
269         LoopState::getNormal(LoopStmt, LCtx, maxVisitOnPath));
270     return State;
271   }
272 
273   unsigned outerStep = (LS.isEmpty() ? 1 : LS.getHead().getMaxStep());
274 
275   unsigned innerMaxStep = maxStep * outerStep;
276   if (innerMaxStep > MAXIMUM_STEP_UNROLLED)
277     State = State->add<LoopStack>(
278         LoopState::getNormal(LoopStmt, LCtx, maxVisitOnPath));
279   else
280     State = State->add<LoopStack>(
281         LoopState::getUnrolled(LoopStmt, LCtx, innerMaxStep));
282   return State;
283 }
284 
285 bool isUnrolledState(ProgramStateRef State) {
286   auto LS = State->get<LoopStack>();
287   if (LS.isEmpty() || !LS.getHead().isUnrolled())
288     return false;
289   return true;
290 }
291 }
292 }
293