contrib/llvm/tools/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp

   1 //===--- CallAndMessageChecker.cpp ------------------------------*- 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 defines CallAndMessageChecker, a builtin checker that checks for various
  11 // errors of call and objc message expressions.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "ClangSACheckers.h"
  16 #include "clang/StaticAnalyzer/Core/Checker.h"
  17 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  18 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
  19 #include "clang/StaticAnalyzer/Core/PathSensitive/ObjCMessage.h"
  20 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
  21 #include "clang/AST/ParentMap.h"
  22 #include "clang/Basic/TargetInfo.h"
  23
  24 using namespace clang;
  25 using namespace ento;
  26
  27 namespace {
  28 class CallAndMessageChecker
  29   : public Checker< check::PreStmt<CallExpr>, check::PreObjCMessage > {
  30   mutable llvm::OwningPtr<BugType> BT_call_null;
  31   mutable llvm::OwningPtr<BugType> BT_call_undef;
  32   mutable llvm::OwningPtr<BugType> BT_call_arg;
  33   mutable llvm::OwningPtr<BugType> BT_msg_undef;
  34   mutable llvm::OwningPtr<BugType> BT_msg_arg;
  35   mutable llvm::OwningPtr<BugType> BT_msg_ret;
  36 public:
  37
  38   void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
  39   void checkPreObjCMessage(ObjCMessage msg, CheckerContext &C) const;
  40
  41 private:
  42   static void PreVisitProcessArgs(CheckerContext &C,CallOrObjCMessage callOrMsg,
  43                              const char *BT_desc, llvm::OwningPtr<BugType> &BT);
  44   static bool PreVisitProcessArg(CheckerContext &C, SVal V,SourceRange argRange,
  45           const Expr *argEx, const char *BT_desc, llvm::OwningPtr<BugType> &BT);
  46
  47   static void EmitBadCall(BugType *BT, CheckerContext &C, const CallExpr *CE);
  48   void emitNilReceiverBug(CheckerContext &C, const ObjCMessage &msg,
  49                           ExplodedNode *N) const;
  50
  51   void HandleNilReceiver(CheckerContext &C,
  52                          const ProgramState *state,
  53                          ObjCMessage msg) const;
  54
  55   static void LazyInit_BT(const char *desc, llvm::OwningPtr<BugType> &BT) {
  56     if (!BT)
  57       BT.reset(new BuiltinBug(desc));
  58   }
  59 };
  60 } // end anonymous namespace
  61
  62 void CallAndMessageChecker::EmitBadCall(BugType *BT, CheckerContext &C,
  63                                         const CallExpr *CE) {
  64   ExplodedNode *N = C.generateSink();
  65   if (!N)
  66     return;
  67
  68   BugReport *R = new BugReport(*BT, BT->getName(), N);
  69   R->addVisitor(bugreporter::getTrackNullOrUndefValueVisitor(N,
  70                                bugreporter::GetCalleeExpr(N)));
  71   C.EmitReport(R);
  72 }
  73
  74 void CallAndMessageChecker::PreVisitProcessArgs(CheckerContext &C,
  75                                                 CallOrObjCMessage callOrMsg,
  76                                                 const char *BT_desc,
  77                                                 llvm::OwningPtr<BugType> &BT) {
  78   for (unsigned i = 0, e = callOrMsg.getNumArgs(); i != e; ++i)
  79     if (PreVisitProcessArg(C, callOrMsg.getArgSVal(i),
  80                            callOrMsg.getArgSourceRange(i), callOrMsg.getArg(i),
  81                            BT_desc, BT))
  82       return;
  83 }
  84
  85 bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C,
  86                                                SVal V, SourceRange argRange,
  87                                                const Expr *argEx,
  88                                                const char *BT_desc,
  89                                                llvm::OwningPtr<BugType> &BT) {
  90
  91   if (V.isUndef()) {
  92     if (ExplodedNode *N = C.generateSink()) {
  93       LazyInit_BT(BT_desc, BT);
  94
  95       // Generate a report for this bug.
  96       BugReport *R = new BugReport(*BT, BT->getName(), N);
  97       R->addRange(argRange);
  98       if (argEx)
  99         R->addVisitor(bugreporter::getTrackNullOrUndefValueVisitor(N, argEx));
 100       C.EmitReport(R);
 101     }
 102     return true;
 103   }
 104
 105   if (const nonloc::LazyCompoundVal *LV =
 106         dyn_cast<nonloc::LazyCompoundVal>(&V)) {
 107
 108     class FindUninitializedField {
 109     public:
 110       SmallVector<const FieldDecl *, 10> FieldChain;
 111     private:
 112       ASTContext &C;
 113       StoreManager &StoreMgr;
 114       MemRegionManager &MrMgr;
 115       Store store;
 116     public:
 117       FindUninitializedField(ASTContext &c, StoreManager &storeMgr,
 118                              MemRegionManager &mrMgr, Store s)
 119       : C(c), StoreMgr(storeMgr), MrMgr(mrMgr), store(s) {}
 120
 121       bool Find(const TypedValueRegion *R) {
 122         QualType T = R->getValueType();
 123         if (const RecordType *RT = T->getAsStructureType()) {
 124           const RecordDecl *RD = RT->getDecl()->getDefinition();
 125           assert(RD && "Referred record has no definition");
 126           for (RecordDecl::field_iterator I =
 127                RD->field_begin(), E = RD->field_end(); I!=E; ++I) {
 128             const FieldRegion *FR = MrMgr.getFieldRegion(*I, R);
 129             FieldChain.push_back(*I);
 130             T = (*I)->getType();
 131             if (T->getAsStructureType()) {
 132               if (Find(FR))
 133                 return true;
 134             }
 135             else {
 136               const SVal &V = StoreMgr.Retrieve(store, loc::MemRegionVal(FR));
 137               if (V.isUndef())
 138                 return true;
 139             }
 140             FieldChain.pop_back();
 141           }
 142         }
 143
 144         return false;
 145       }
 146     };
 147
 148     const LazyCompoundValData *D = LV->getCVData();
 149     FindUninitializedField F(C.getASTContext(),
 150                              C.getState()->getStateManager().getStoreManager(),
 151                              C.getSValBuilder().getRegionManager(),
 152                              D->getStore());
 153
 154     if (F.Find(D->getRegion())) {
 155       if (ExplodedNode *N = C.generateSink()) {
 156         LazyInit_BT(BT_desc, BT);
 157         llvm::SmallString<512> Str;
 158         llvm::raw_svector_ostream os(Str);
 159         os << "Passed-by-value struct argument contains uninitialized data";
 160
 161         if (F.FieldChain.size() == 1)
 162           os << " (e.g., field: '" << *F.FieldChain[0] << "')";
 163         else {
 164           os << " (e.g., via the field chain: '";
 165           bool first = true;
 166           for (SmallVectorImpl<const FieldDecl *>::iterator
 167                DI = F.FieldChain.begin(), DE = F.FieldChain.end(); DI!=DE;++DI){
 168             if (first)
 169               first = false;
 170             else
 171               os << '.';
 172             os << **DI;
 173           }
 174           os << "')";
 175         }
 176
 177         // Generate a report for this bug.
 178         BugReport *R = new BugReport(*BT, os.str(), N);
 179         R->addRange(argRange);
 180
 181         // FIXME: enhance track back for uninitialized value for arbitrary
 182         // memregions
 183         C.EmitReport(R);
 184       }
 185       return true;
 186     }
 187   }
 188
 189   return false;
 190 }
 191
 192 void CallAndMessageChecker::checkPreStmt(const CallExpr *CE,
 193                                          CheckerContext &C) const{
 194
 195   const Expr *Callee = CE->getCallee()->IgnoreParens();
 196   SVal L = C.getState()->getSVal(Callee);
 197
 198   if (L.isUndef()) {
 199     if (!BT_call_undef)
 200       BT_call_undef.reset(new BuiltinBug("Called function pointer is an "
 201                                          "uninitalized pointer value"));
 202     EmitBadCall(BT_call_undef.get(), C, CE);
 203     return;
 204   }
 205
 206   if (isa<loc::ConcreteInt>(L)) {
 207     if (!BT_call_null)
 208       BT_call_null.reset(
 209         new BuiltinBug("Called function pointer is null (null dereference)"));
 210     EmitBadCall(BT_call_null.get(), C, CE);
 211   }
 212
 213   PreVisitProcessArgs(C, CallOrObjCMessage(CE, C.getState()),
 214                       "Function call argument is an uninitialized value",
 215                       BT_call_arg);
 216 }
 217
 218 void CallAndMessageChecker::checkPreObjCMessage(ObjCMessage msg,
 219                                                 CheckerContext &C) const {
 220
 221   const ProgramState *state = C.getState();
 222
 223   // FIXME: Handle 'super'?
 224   if (const Expr *receiver = msg.getInstanceReceiver()) {
 225     SVal recVal = state->getSVal(receiver);
 226     if (recVal.isUndef()) {
 227       if (ExplodedNode *N = C.generateSink()) {
 228         if (!BT_msg_undef)
 229           BT_msg_undef.reset(new BuiltinBug("Receiver in message expression is "
 230                                             "an uninitialized value"));
 231         BugReport *R =
 232           new BugReport(*BT_msg_undef, BT_msg_undef->getName(), N);
 233         R->addRange(receiver->getSourceRange());
 234         R->addVisitor(bugreporter::getTrackNullOrUndefValueVisitor(N,
 235                                                                    receiver));
 236         C.EmitReport(R);
 237       }
 238       return;
 239     } else {
 240       // Bifurcate the state into nil and non-nil ones.
 241       DefinedOrUnknownSVal receiverVal = cast<DefinedOrUnknownSVal>(recVal);
 242
 243       const ProgramState *notNilState, *nilState;
 244       llvm::tie(notNilState, nilState) = state->assume(receiverVal);
 245
 246       // Handle receiver must be nil.
 247       if (nilState && !notNilState) {
 248         HandleNilReceiver(C, state, msg);
 249         return;
 250       }
 251     }
 252   }
 253
 254   const char *bugDesc = msg.isPropertySetter() ?
 255                      "Argument for property setter is an uninitialized value"
 256                    : "Argument in message expression is an uninitialized value";
 257   // Check for any arguments that are uninitialized/undefined.
 258   PreVisitProcessArgs(C, CallOrObjCMessage(msg, state), bugDesc, BT_msg_arg);
 259 }
 260
 261 void CallAndMessageChecker::emitNilReceiverBug(CheckerContext &C,
 262                                                const ObjCMessage &msg,
 263                                                ExplodedNode *N) const {
 264
 265   if (!BT_msg_ret)
 266     BT_msg_ret.reset(
 267       new BuiltinBug("Receiver in message expression is "
 268                      "'nil' and returns a garbage value"));
 269
 270   llvm::SmallString<200> buf;
 271   llvm::raw_svector_ostream os(buf);
 272   os << "The receiver of message '" << msg.getSelector().getAsString()
 273      << "' is nil and returns a value of type '"
 274      << msg.getType(C.getASTContext()).getAsString() << "' that will be garbage";
 275
 276   BugReport *report = new BugReport(*BT_msg_ret, os.str(), N);
 277   if (const Expr *receiver = msg.getInstanceReceiver()) {
 278     report->addRange(receiver->getSourceRange());
 279     report->addVisitor(bugreporter::getTrackNullOrUndefValueVisitor(N,
 280                                                                     receiver));
 281   }
 282   C.EmitReport(report);
 283 }
 284
 285 static bool supportsNilWithFloatRet(const llvm::Triple &triple) {
 286   return triple.getVendor() == llvm::Triple::Apple &&
 287          (!triple.isMacOSXVersionLT(10,5) ||
 288           triple.getArch() == llvm::Triple::arm ||
 289           triple.getArch() == llvm::Triple::thumb);
 290 }
 291
 292 void CallAndMessageChecker::HandleNilReceiver(CheckerContext &C,
 293                                               const ProgramState *state,
 294                                               ObjCMessage msg) const {
 295   ASTContext &Ctx = C.getASTContext();
 296
 297   // Check the return type of the message expression.  A message to nil will
 298   // return different values depending on the return type and the architecture.
 299   QualType RetTy = msg.getType(Ctx);
 300
 301   CanQualType CanRetTy = Ctx.getCanonicalType(RetTy);
 302
 303   if (CanRetTy->isStructureOrClassType()) {
 304     // FIXME: At some point we shouldn't rely on isConsumedExpr(), but instead
 305     // have the "use of undefined value" be smarter about where the
 306     // undefined value came from.
 307     if (C.getPredecessor()->getParentMap().isConsumedExpr(msg.getOriginExpr())){
 308       if (ExplodedNode *N = C.generateSink(state))
 309         emitNilReceiverBug(C, msg, N);
 310       return;
 311     }
 312
 313     // The result is not consumed by a surrounding expression.  Just propagate
 314     // the current state.
 315     C.addTransition(state);
 316     return;
 317   }
 318
 319   // Other cases: check if the return type is smaller than void*.
 320   if (CanRetTy != Ctx.VoidTy &&
 321       C.getPredecessor()->getParentMap().isConsumedExpr(msg.getOriginExpr())) {
 322     // Compute: sizeof(void *) and sizeof(return type)
 323     const uint64_t voidPtrSize = Ctx.getTypeSize(Ctx.VoidPtrTy);
 324     const uint64_t returnTypeSize = Ctx.getTypeSize(CanRetTy);
 325
 326     if (voidPtrSize < returnTypeSize &&
 327         !(supportsNilWithFloatRet(Ctx.getTargetInfo().getTriple()) &&
 328           (Ctx.FloatTy == CanRetTy ||
 329            Ctx.DoubleTy == CanRetTy ||
 330            Ctx.LongDoubleTy == CanRetTy ||
 331            Ctx.LongLongTy == CanRetTy ||
 332            Ctx.UnsignedLongLongTy == CanRetTy))) {
 333       if (ExplodedNode *N = C.generateSink(state))
 334         emitNilReceiverBug(C, msg, N);
 335       return;
 336     }
 337
 338     // Handle the safe cases where the return value is 0 if the
 339     // receiver is nil.
 340     //
 341     // FIXME: For now take the conservative approach that we only
 342     // return null values if we *know* that the receiver is nil.
 343     // This is because we can have surprises like:
 344     //
 345     //   ... = [[NSScreens screens] objectAtIndex:0];
 346     //
 347     // What can happen is that [... screens] could return nil, but
 348     // it most likely isn't nil.  We should assume the semantics
 349     // of this case unless we have *a lot* more knowledge.
 350     //
 351     SVal V = C.getSValBuilder().makeZeroVal(msg.getType(Ctx));
 352     C.generateNode(state->BindExpr(msg.getOriginExpr(), V));
 353     return;
 354   }
 355
 356   C.addTransition(state);
 357 }
 358
 359 void ento::registerCallAndMessageChecker(CheckerManager &mgr) {
 360   mgr.registerChecker<CallAndMessageChecker>();
 361 }