CallAndMessageChecker.cpp revision d1e5a89226da79f7e6f43d40facc46abda9e5245 
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
24using namespace clang;
25using namespace ento;
26
27namespace {
28class 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;
36public:
37
38  void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
39  void checkPreObjCMessage(ObjCMessage msg, CheckerContext &C) const;
40
41private:
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
62void 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
74void 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
85bool 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
192void 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
218void 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
261void 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
285static 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
292void 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
359void ento::registerCallAndMessageChecker(CheckerManager &mgr) {
360  mgr.registerChecker<CallAndMessageChecker>();
361}
362