CallAndMessageChecker.cpp revision 04291a7c76e16a2dc5433c80c3d13c826bf372dc 
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/BugReporter/BugType.h"
19#include "clang/StaticAnalyzer/PathSensitive/CheckerVisitor.h"
20
21using namespace clang;
22using namespace ento;
23
24namespace {
25class 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;
33public:
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
47private:
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
67void ento::RegisterCallAndMessageChecker(ExprEngine &Eng) {
68  Eng.registerCheck(new CallAndMessageChecker());
69}
70
71void 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
83void 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
94bool 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
201void 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
227void 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
256bool CallAndMessageChecker::evalNilReceiver(CheckerContext &C,
257                                            ObjCMessage msg) {
258  HandleNilReceiver(C, C.getState(), msg);
259  return true; // Nil receiver is not handled elsewhere.
260}
261
262void 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
286static 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
293void 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}
359