1 //=-- ExprEngineObjC.cpp - ExprEngine support for Objective-C ---*- 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 defines ExprEngine's support for Objective-C expressions.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/StmtObjC.h"
15 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
16 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
17 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
18
19 using namespace clang;
20 using namespace ento;
21
VisitLvalObjCIvarRefExpr(const ObjCIvarRefExpr * Ex,ExplodedNode * Pred,ExplodedNodeSet & Dst)22 void ExprEngine::VisitLvalObjCIvarRefExpr(const ObjCIvarRefExpr *Ex,
23 ExplodedNode *Pred,
24 ExplodedNodeSet &Dst) {
25 ProgramStateRef state = Pred->getState();
26 const LocationContext *LCtx = Pred->getLocationContext();
27 SVal baseVal = state->getSVal(Ex->getBase(), LCtx);
28 SVal location = state->getLValue(Ex->getDecl(), baseVal);
29
30 ExplodedNodeSet dstIvar;
31 StmtNodeBuilder Bldr(Pred, dstIvar, *currBldrCtx);
32 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, location));
33
34 // Perform the post-condition check of the ObjCIvarRefExpr and store
35 // the created nodes in 'Dst'.
36 getCheckerManager().runCheckersForPostStmt(Dst, dstIvar, Ex, *this);
37 }
38
VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt * S,ExplodedNode * Pred,ExplodedNodeSet & Dst)39 void ExprEngine::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S,
40 ExplodedNode *Pred,
41 ExplodedNodeSet &Dst) {
42 getCheckerManager().runCheckersForPreStmt(Dst, Pred, S, *this);
43 }
44
VisitObjCForCollectionStmt(const ObjCForCollectionStmt * S,ExplodedNode * Pred,ExplodedNodeSet & Dst)45 void ExprEngine::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S,
46 ExplodedNode *Pred,
47 ExplodedNodeSet &Dst) {
48
49 // ObjCForCollectionStmts are processed in two places. This method
50 // handles the case where an ObjCForCollectionStmt* occurs as one of the
51 // statements within a basic block. This transfer function does two things:
52 //
53 // (1) binds the next container value to 'element'. This creates a new
54 // node in the ExplodedGraph.
55 //
56 // (2) binds the value 0/1 to the ObjCForCollectionStmt* itself, indicating
57 // whether or not the container has any more elements. This value
58 // will be tested in ProcessBranch. We need to explicitly bind
59 // this value because a container can contain nil elements.
60 //
61 // FIXME: Eventually this logic should actually do dispatches to
62 // 'countByEnumeratingWithState:objects:count:' (NSFastEnumeration).
63 // This will require simulating a temporary NSFastEnumerationState, either
64 // through an SVal or through the use of MemRegions. This value can
65 // be affixed to the ObjCForCollectionStmt* instead of 0/1; when the loop
66 // terminates we reclaim the temporary (it goes out of scope) and we
67 // we can test if the SVal is 0 or if the MemRegion is null (depending
68 // on what approach we take).
69 //
70 // For now: simulate (1) by assigning either a symbol or nil if the
71 // container is empty. Thus this transfer function will by default
72 // result in state splitting.
73
74 const Stmt *elem = S->getElement();
75 ProgramStateRef state = Pred->getState();
76 SVal elementV;
77
78 if (const DeclStmt *DS = dyn_cast<DeclStmt>(elem)) {
79 const VarDecl *elemD = cast<VarDecl>(DS->getSingleDecl());
80 assert(elemD->getInit() == nullptr);
81 elementV = state->getLValue(elemD, Pred->getLocationContext());
82 }
83 else {
84 elementV = state->getSVal(elem, Pred->getLocationContext());
85 }
86
87 ExplodedNodeSet dstLocation;
88 evalLocation(dstLocation, S, elem, Pred, state, elementV, nullptr, false);
89
90 ExplodedNodeSet Tmp;
91 StmtNodeBuilder Bldr(Pred, Tmp, *currBldrCtx);
92
93 for (ExplodedNodeSet::iterator NI = dstLocation.begin(),
94 NE = dstLocation.end(); NI!=NE; ++NI) {
95 Pred = *NI;
96 ProgramStateRef state = Pred->getState();
97 const LocationContext *LCtx = Pred->getLocationContext();
98
99 // Handle the case where the container still has elements.
100 SVal TrueV = svalBuilder.makeTruthVal(1);
101 ProgramStateRef hasElems = state->BindExpr(S, LCtx, TrueV);
102
103 // Handle the case where the container has no elements.
104 SVal FalseV = svalBuilder.makeTruthVal(0);
105 ProgramStateRef noElems = state->BindExpr(S, LCtx, FalseV);
106
107 if (Optional<loc::MemRegionVal> MV = elementV.getAs<loc::MemRegionVal>())
108 if (const TypedValueRegion *R =
109 dyn_cast<TypedValueRegion>(MV->getRegion())) {
110 // FIXME: The proper thing to do is to really iterate over the
111 // container. We will do this with dispatch logic to the store.
112 // For now, just 'conjure' up a symbolic value.
113 QualType T = R->getValueType();
114 assert(Loc::isLocType(T));
115 SymbolRef Sym = SymMgr.conjureSymbol(elem, LCtx, T,
116 currBldrCtx->blockCount());
117 SVal V = svalBuilder.makeLoc(Sym);
118 hasElems = hasElems->bindLoc(elementV, V);
119
120 // Bind the location to 'nil' on the false branch.
121 SVal nilV = svalBuilder.makeIntVal(0, T);
122 noElems = noElems->bindLoc(elementV, nilV);
123 }
124
125 // Create the new nodes.
126 Bldr.generateNode(S, Pred, hasElems);
127 Bldr.generateNode(S, Pred, noElems);
128 }
129
130 // Finally, run any custom checkers.
131 // FIXME: Eventually all pre- and post-checks should live in VisitStmt.
132 getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
133 }
134
VisitObjCMessage(const ObjCMessageExpr * ME,ExplodedNode * Pred,ExplodedNodeSet & Dst)135 void ExprEngine::VisitObjCMessage(const ObjCMessageExpr *ME,
136 ExplodedNode *Pred,
137 ExplodedNodeSet &Dst) {
138 CallEventManager &CEMgr = getStateManager().getCallEventManager();
139 CallEventRef<ObjCMethodCall> Msg =
140 CEMgr.getObjCMethodCall(ME, Pred->getState(), Pred->getLocationContext());
141
142 // Handle the previsits checks.
143 ExplodedNodeSet dstPrevisit;
144 getCheckerManager().runCheckersForPreObjCMessage(dstPrevisit, Pred,
145 *Msg, *this);
146 ExplodedNodeSet dstGenericPrevisit;
147 getCheckerManager().runCheckersForPreCall(dstGenericPrevisit, dstPrevisit,
148 *Msg, *this);
149
150 // Proceed with evaluate the message expression.
151 ExplodedNodeSet dstEval;
152 StmtNodeBuilder Bldr(dstGenericPrevisit, dstEval, *currBldrCtx);
153
154 for (ExplodedNodeSet::iterator DI = dstGenericPrevisit.begin(),
155 DE = dstGenericPrevisit.end(); DI != DE; ++DI) {
156 ExplodedNode *Pred = *DI;
157 ProgramStateRef State = Pred->getState();
158 CallEventRef<ObjCMethodCall> UpdatedMsg = Msg.cloneWithState(State);
159
160 if (UpdatedMsg->isInstanceMessage()) {
161 SVal recVal = UpdatedMsg->getReceiverSVal();
162 if (!recVal.isUndef()) {
163 // Bifurcate the state into nil and non-nil ones.
164 DefinedOrUnknownSVal receiverVal =
165 recVal.castAs<DefinedOrUnknownSVal>();
166
167 ProgramStateRef notNilState, nilState;
168 std::tie(notNilState, nilState) = State->assume(receiverVal);
169
170 // There are three cases: can be nil or non-nil, must be nil, must be
171 // non-nil. We ignore must be nil, and merge the rest two into non-nil.
172 // FIXME: This ignores many potential bugs (<rdar://problem/11733396>).
173 // Revisit once we have lazier constraints.
174 if (nilState && !notNilState) {
175 continue;
176 }
177
178 // Check if the "raise" message was sent.
179 assert(notNilState);
180 if (ObjCNoRet.isImplicitNoReturn(ME)) {
181 // If we raise an exception, for now treat it as a sink.
182 // Eventually we will want to handle exceptions properly.
183 Bldr.generateSink(ME, Pred, State);
184 continue;
185 }
186
187 // Generate a transition to non-Nil state.
188 if (notNilState != State) {
189 Pred = Bldr.generateNode(ME, Pred, notNilState);
190 assert(Pred && "Should have cached out already!");
191 }
192 }
193 } else {
194 // Check for special class methods that are known to not return
195 // and that we should treat as a sink.
196 if (ObjCNoRet.isImplicitNoReturn(ME)) {
197 // If we raise an exception, for now treat it as a sink.
198 // Eventually we will want to handle exceptions properly.
199 Bldr.generateSink(ME, Pred, Pred->getState());
200 continue;
201 }
202 }
203
204 defaultEvalCall(Bldr, Pred, *UpdatedMsg);
205 }
206
207 ExplodedNodeSet dstPostvisit;
208 getCheckerManager().runCheckersForPostCall(dstPostvisit, dstEval,
209 *Msg, *this);
210
211 // Finally, perform the post-condition check of the ObjCMessageExpr and store
212 // the created nodes in 'Dst'.
213 getCheckerManager().runCheckersForPostObjCMessage(Dst, dstPostvisit,
214 *Msg, *this);
215 }
216