ExprEngineObjC.cpp revision de507eaf3cb54d3cb234dc14499c10ab3373d15f 
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/Calls.h"
17#include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
18
19using namespace clang;
20using namespace ento;
21
22void 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, *currentBuilderContext);
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
39void ExprEngine::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S,
40                                             ExplodedNode *Pred,
41                                             ExplodedNodeSet &Dst) {
42  getCheckerManager().runCheckersForPreStmt(Dst, Pred, S, *this);
43}
44
45void 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() == 0);
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, NULL, false);
89
90  ExplodedNodeSet Tmp;
91  StmtNodeBuilder Bldr(Pred, Tmp, *currentBuilderContext);
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 (loc::MemRegionVal *MV = dyn_cast<loc::MemRegionVal>(&elementV))
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        unsigned Count = currentBuilderContext->getCurrentBlockCount();
116        SymbolRef Sym = SymMgr.getConjuredSymbol(elem, LCtx, T, Count);
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
135static bool isSubclass(const ObjCInterfaceDecl *Class, IdentifierInfo *II) {
136  if (!Class)
137    return false;
138  if (Class->getIdentifier() == II)
139    return true;
140  return isSubclass(Class->getSuperClass(), II);
141}
142
143void ExprEngine::VisitObjCMessage(const ObjCMethodCall &msg,
144                                  ExplodedNode *Pred,
145                                  ExplodedNodeSet &Dst) {
146
147  // Handle the previsits checks.
148  ExplodedNodeSet dstPrevisit;
149  getCheckerManager().runCheckersForPreObjCMessage(dstPrevisit, Pred,
150                                                   msg, *this);
151
152  // Proceed with evaluate the message expression.
153  ExplodedNodeSet dstEval;
154  StmtNodeBuilder Bldr(dstPrevisit, dstEval, *currentBuilderContext);
155
156  for (ExplodedNodeSet::iterator DI = dstPrevisit.begin(),
157       DE = dstPrevisit.end(); DI != DE; ++DI) {
158
159    ExplodedNode *Pred = *DI;
160    bool RaisesException = false;
161
162    if (msg.isInstanceMessage()) {
163      SVal recVal = msg.getReceiverSVal();
164      if (!recVal.isUndef()) {
165        // Bifurcate the state into nil and non-nil ones.
166        DefinedOrUnknownSVal receiverVal = cast<DefinedOrUnknownSVal>(recVal);
167
168        ProgramStateRef state = Pred->getState();
169        ProgramStateRef notNilState, nilState;
170        llvm::tie(notNilState, nilState) = state->assume(receiverVal);
171
172        // There are three cases: can be nil or non-nil, must be nil, must be
173        // non-nil. We ignore must be nil, and merge the rest two into non-nil.
174        // FIXME: This ignores many potential bugs (<rdar://problem/11733396>).
175        // Revisit once we have lazier constraints.
176        if (nilState && !notNilState) {
177          continue;
178        }
179
180        // Check if the "raise" message was sent.
181        assert(notNilState);
182        if (msg.getSelector() == RaiseSel)
183          RaisesException = true;
184
185        // If we raise an exception, for now treat it as a sink.
186        // Eventually we will want to handle exceptions properly.
187        // Dispatch to plug-in transfer function.
188        evalObjCMessage(Bldr, msg, Pred, notNilState, RaisesException);
189      }
190    } else {
191      // Check for special class methods.
192      if (const ObjCInterfaceDecl *Iface = msg.getReceiverInterface()) {
193        if (!NSExceptionII) {
194          ASTContext &Ctx = getContext();
195          NSExceptionII = &Ctx.Idents.get("NSException");
196        }
197
198        if (isSubclass(Iface, NSExceptionII)) {
199          enum { NUM_RAISE_SELECTORS = 2 };
200
201          // Lazily create a cache of the selectors.
202          if (!NSExceptionInstanceRaiseSelectors) {
203            ASTContext &Ctx = getContext();
204            NSExceptionInstanceRaiseSelectors =
205              new Selector[NUM_RAISE_SELECTORS];
206            SmallVector<IdentifierInfo*, NUM_RAISE_SELECTORS> II;
207            unsigned idx = 0;
208
209            // raise:format:
210            II.push_back(&Ctx.Idents.get("raise"));
211            II.push_back(&Ctx.Idents.get("format"));
212            NSExceptionInstanceRaiseSelectors[idx++] =
213              Ctx.Selectors.getSelector(II.size(), &II[0]);
214
215            // raise:format:arguments:
216            II.push_back(&Ctx.Idents.get("arguments"));
217            NSExceptionInstanceRaiseSelectors[idx++] =
218              Ctx.Selectors.getSelector(II.size(), &II[0]);
219          }
220
221          Selector S = msg.getSelector();
222          for (unsigned i = 0; i < NUM_RAISE_SELECTORS; ++i) {
223            if (S == NSExceptionInstanceRaiseSelectors[i]) {
224              RaisesException = true;
225              break;
226            }
227          }
228        }
229      }
230
231      // If we raise an exception, for now treat it as a sink.
232      // Eventually we will want to handle exceptions properly.
233      // Dispatch to plug-in transfer function.
234      evalObjCMessage(Bldr, msg, Pred, Pred->getState(), RaisesException);
235    }
236  }
237
238  // Finally, perform the post-condition check of the ObjCMessageExpr and store
239  // the created nodes in 'Dst'.
240  getCheckerManager().runCheckersForPostObjCMessage(Dst, dstEval, msg, *this);
241}
242
243void ExprEngine::evalObjCMessage(StmtNodeBuilder &Bldr,
244                                 const ObjCMethodCall &msg,
245                                 ExplodedNode *Pred,
246                                 ProgramStateRef state,
247                                 bool GenSink) {
248  // First handle the return value.
249  SVal ReturnValue = UnknownVal();
250
251  // Some method families have known return values.
252  switch (msg.getMethodFamily()) {
253  default:
254    break;
255  case OMF_autorelease:
256  case OMF_retain:
257  case OMF_self: {
258    // These methods return their receivers.
259    ReturnValue = msg.getReceiverSVal();
260    break;
261  }
262  }
263
264  const LocationContext *LCtx = Pred->getLocationContext();
265  unsigned BlockCount = currentBuilderContext->getCurrentBlockCount();
266
267  // If we failed to figure out the return value, use a conjured value instead.
268  if (ReturnValue.isUnknown()) {
269    SValBuilder &SVB = getSValBuilder();
270    QualType ResultTy = msg.getResultType();
271    const Expr *CurrentE = cast<Expr>(currentStmt);
272    ReturnValue = SVB.getConjuredSymbolVal(NULL, CurrentE, LCtx, ResultTy,
273                                           BlockCount);
274  }
275
276  // Bind the return value.
277  state = state->BindExpr(currentStmt, LCtx, ReturnValue);
278
279  // Invalidate the arguments (and the receiver)
280  state = msg.invalidateRegions(BlockCount, state);
281
282  // And create the new node.
283  Bldr.generateNode(msg.getOriginExpr(), Pred, state, GenSink);
284  assert(Bldr.hasGeneratedNodes());
285}
286
287