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