contrib/llvm/tools/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp

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