blob: f3306d136bc0c7b544125f585b7d7fcd78ac77c4 [file] [log] [blame]
Zhongxing Xud02174c2009-11-24 04:45:44 +00001//===--- CallAndMessageChecker.cpp ------------------------------*- C++ -*--==//
Zhongxing Xu8958fff2009-11-03 06:46:03 +00002//
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//
Zhongxing Xud02174c2009-11-24 04:45:44 +000010// This defines CallAndMessageChecker, a builtin checker that checks for various
11// errors of call and objc message expressions.
Zhongxing Xu8958fff2009-11-03 06:46:03 +000012//
13//===----------------------------------------------------------------------===//
14
Argyrios Kyrtzidisd2592a32010-12-22 18:53:44 +000015#include "ExprEngineInternalChecks.h"
Benjamin Kramer5e2d2c22010-03-27 21:19:47 +000016#include "clang/AST/ParentMap.h"
17#include "clang/Basic/TargetInfo.h"
Argyrios Kyrtzidis98cabba2010-12-22 18:51:49 +000018#include "clang/GR/BugReporter/BugType.h"
19#include "clang/GR/PathSensitive/CheckerVisitor.h"
Zhongxing Xu8958fff2009-11-03 06:46:03 +000020
21using namespace clang;
Argyrios Kyrtzidis5a4f98f2010-12-22 18:53:20 +000022using namespace GR;
Zhongxing Xu8958fff2009-11-03 06:46:03 +000023
Ted Kremenekf493f492009-11-11 05:50:44 +000024namespace {
Kovarththanan Rajaratnamba5fb5a2009-11-28 06:07:30 +000025class CallAndMessageChecker
Zhongxing Xud02174c2009-11-24 04:45:44 +000026 : public CheckerVisitor<CallAndMessageChecker> {
Ted Kremenekc79d7d42009-11-21 01:25:37 +000027 BugType *BT_call_null;
Ted Kremenek091b5882010-03-18 02:17:27 +000028 BugType *BT_call_undef;
Ted Kremenekc79d7d42009-11-21 01:25:37 +000029 BugType *BT_call_arg;
30 BugType *BT_msg_undef;
31 BugType *BT_msg_arg;
Ted Kremenekfee96e02009-11-24 21:41:28 +000032 BugType *BT_msg_ret;
Ted Kremenekf493f492009-11-11 05:50:44 +000033public:
Zhongxing Xud02174c2009-11-24 04:45:44 +000034 CallAndMessageChecker() :
Ted Kremenekc79d7d42009-11-21 01:25:37 +000035 BT_call_null(0), BT_call_undef(0), BT_call_arg(0),
Ted Kremenekfee96e02009-11-24 21:41:28 +000036 BT_msg_undef(0), BT_msg_arg(0), BT_msg_ret(0) {}
Zhongxing Xu2055eff2009-11-24 07:06:39 +000037
Ted Kremenekf493f492009-11-11 05:50:44 +000038 static void *getTag() {
39 static int x = 0;
40 return &x;
41 }
Ted Kremenekfee96e02009-11-24 21:41:28 +000042
Ted Kremenekf493f492009-11-11 05:50:44 +000043 void PreVisitCallExpr(CheckerContext &C, const CallExpr *CE);
Ted Kremenek64fa8582009-11-21 00:49:41 +000044 void PreVisitObjCMessageExpr(CheckerContext &C, const ObjCMessageExpr *ME);
Ted Kremenek9c149532010-12-01 21:57:22 +000045 bool evalNilReceiver(CheckerContext &C, const ObjCMessageExpr *ME);
Ted Kremenekfee96e02009-11-24 21:41:28 +000046
Ted Kremenekc79d7d42009-11-21 01:25:37 +000047private:
Ted Kremenek81337162010-03-18 03:22:29 +000048 bool PreVisitProcessArg(CheckerContext &C, const Expr *Ex,
49 const char *BT_desc, BugType *&BT);
50
Ted Kremenekc79d7d42009-11-21 01:25:37 +000051 void EmitBadCall(BugType *BT, CheckerContext &C, const CallExpr *CE);
Ted Kremenekc8413fd2010-12-02 07:49:45 +000052 void emitNilReceiverBug(CheckerContext &C, const ObjCMessageExpr *ME,
Ted Kremenekfee96e02009-11-24 21:41:28 +000053 ExplodedNode *N);
Ted Kremenek091b5882010-03-18 02:17:27 +000054
Ted Kremenekfee96e02009-11-24 21:41:28 +000055 void HandleNilReceiver(CheckerContext &C, const GRState *state,
Ted Kremenek091b5882010-03-18 02:17:27 +000056 const ObjCMessageExpr *ME);
57
Ted Kremenek81337162010-03-18 03:22:29 +000058 void LazyInit_BT(const char *desc, BugType *&BT) {
59 if (!BT)
60 BT = new BuiltinBug(desc);
Ted Kremenek091b5882010-03-18 02:17:27 +000061 }
Ted Kremenekf493f492009-11-11 05:50:44 +000062};
63} // end anonymous namespace
64
Argyrios Kyrtzidisd2592a32010-12-22 18:53:44 +000065void GR::RegisterCallAndMessageChecker(ExprEngine &Eng) {
Zhongxing Xud02174c2009-11-24 04:45:44 +000066 Eng.registerCheck(new CallAndMessageChecker());
Zhongxing Xu8958fff2009-11-03 06:46:03 +000067}
68
Zhongxing Xud02174c2009-11-24 04:45:44 +000069void CallAndMessageChecker::EmitBadCall(BugType *BT, CheckerContext &C,
70 const CallExpr *CE) {
Ted Kremenekd048c6e2010-12-20 21:19:09 +000071 ExplodedNode *N = C.generateSink();
Ted Kremenekc79d7d42009-11-21 01:25:37 +000072 if (!N)
73 return;
Ted Kremenek091b5882010-03-18 02:17:27 +000074
Ted Kremenekc79d7d42009-11-21 01:25:37 +000075 EnhancedBugReport *R = new EnhancedBugReport(*BT, BT->getName(), N);
76 R->addVisitorCreator(bugreporter::registerTrackNullOrUndefValue,
77 bugreporter::GetCalleeExpr(N));
78 C.EmitReport(R);
79}
80
Ted Kremenek81337162010-03-18 03:22:29 +000081bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C,
82 const Expr *Ex,
83 const char *BT_desc,
84 BugType *&BT) {
85
86 const SVal &V = C.getState()->getSVal(Ex);
87
88 if (V.isUndef()) {
Ted Kremenekd048c6e2010-12-20 21:19:09 +000089 if (ExplodedNode *N = C.generateSink()) {
Ted Kremenek81337162010-03-18 03:22:29 +000090 LazyInit_BT(BT_desc, BT);
91
92 // Generate a report for this bug.
93 EnhancedBugReport *R = new EnhancedBugReport(*BT, BT->getName(), N);
94 R->addRange(Ex->getSourceRange());
95 R->addVisitorCreator(bugreporter::registerTrackNullOrUndefValue, Ex);
96 C.EmitReport(R);
97 }
98 return true;
99 }
100
101 if (const nonloc::LazyCompoundVal *LV =
102 dyn_cast<nonloc::LazyCompoundVal>(&V)) {
103
104 class FindUninitializedField {
105 public:
106 llvm::SmallVector<const FieldDecl *, 10> FieldChain;
107 private:
108 ASTContext &C;
109 StoreManager &StoreMgr;
110 MemRegionManager &MrMgr;
111 Store store;
112 public:
113 FindUninitializedField(ASTContext &c, StoreManager &storeMgr,
114 MemRegionManager &mrMgr, Store s)
115 : C(c), StoreMgr(storeMgr), MrMgr(mrMgr), store(s) {}
116
117 bool Find(const TypedRegion *R) {
Zhongxing Xu018220c2010-08-11 06:10:55 +0000118 QualType T = R->getValueType();
Ted Kremenek81337162010-03-18 03:22:29 +0000119 if (const RecordType *RT = T->getAsStructureType()) {
120 const RecordDecl *RD = RT->getDecl()->getDefinition();
121 assert(RD && "Referred record has no definition");
122 for (RecordDecl::field_iterator I =
123 RD->field_begin(), E = RD->field_end(); I!=E; ++I) {
124 const FieldRegion *FR = MrMgr.getFieldRegion(*I, R);
125 FieldChain.push_back(*I);
126 T = (*I)->getType();
127 if (T->getAsStructureType()) {
128 if (Find(FR))
129 return true;
130 }
131 else {
132 const SVal &V = StoreMgr.Retrieve(store, loc::MemRegionVal(FR));
133 if (V.isUndef())
134 return true;
135 }
136 FieldChain.pop_back();
137 }
138 }
139
140 return false;
141 }
142 };
143
144 const LazyCompoundValData *D = LV->getCVData();
145 FindUninitializedField F(C.getASTContext(),
146 C.getState()->getStateManager().getStoreManager(),
Ted Kremenekc8413fd2010-12-02 07:49:45 +0000147 C.getSValBuilder().getRegionManager(),
Ted Kremenek81337162010-03-18 03:22:29 +0000148 D->getStore());
149
150 if (F.Find(D->getRegion())) {
Ted Kremenekd048c6e2010-12-20 21:19:09 +0000151 if (ExplodedNode *N = C.generateSink()) {
Ted Kremenek81337162010-03-18 03:22:29 +0000152 LazyInit_BT(BT_desc, BT);
153 llvm::SmallString<512> Str;
154 llvm::raw_svector_ostream os(Str);
155 os << "Passed-by-value struct argument contains uninitialized data";
156
157 if (F.FieldChain.size() == 1)
Benjamin Kramer900fc632010-04-17 09:33:03 +0000158 os << " (e.g., field: '" << F.FieldChain[0] << "')";
Ted Kremenek81337162010-03-18 03:22:29 +0000159 else {
160 os << " (e.g., via the field chain: '";
161 bool first = true;
162 for (llvm::SmallVectorImpl<const FieldDecl *>::iterator
163 DI = F.FieldChain.begin(), DE = F.FieldChain.end(); DI!=DE;++DI){
164 if (first)
165 first = false;
166 else
167 os << '.';
Benjamin Kramer900fc632010-04-17 09:33:03 +0000168 os << *DI;
Ted Kremenek81337162010-03-18 03:22:29 +0000169 }
170 os << "')";
171 }
172
173 // Generate a report for this bug.
174 EnhancedBugReport *R = new EnhancedBugReport(*BT, os.str(), N);
175 R->addRange(Ex->getSourceRange());
176
177 // FIXME: enhance track back for uninitialized value for arbitrary
178 // memregions
179 C.EmitReport(R);
180 }
181 return true;
182 }
183 }
184
185 return false;
186}
187
Ted Kremenek091b5882010-03-18 02:17:27 +0000188void CallAndMessageChecker::PreVisitCallExpr(CheckerContext &C,
Zhongxing Xud02174c2009-11-24 04:45:44 +0000189 const CallExpr *CE){
Ted Kremenek091b5882010-03-18 02:17:27 +0000190
Ted Kremenekc79d7d42009-11-21 01:25:37 +0000191 const Expr *Callee = CE->getCallee()->IgnoreParens();
Ted Kremenek13976632010-02-08 16:18:51 +0000192 SVal L = C.getState()->getSVal(Callee);
Ted Kremenek091b5882010-03-18 02:17:27 +0000193
Ted Kremenekc79d7d42009-11-21 01:25:37 +0000194 if (L.isUndef()) {
195 if (!BT_call_undef)
196 BT_call_undef =
Ted Kremenek818b4332010-09-09 22:51:55 +0000197 new BuiltinBug("Called function pointer is an uninitalized pointer value");
Ted Kremenekc79d7d42009-11-21 01:25:37 +0000198 EmitBadCall(BT_call_undef, C, CE);
199 return;
200 }
Ted Kremenek091b5882010-03-18 02:17:27 +0000201
Ted Kremenekc79d7d42009-11-21 01:25:37 +0000202 if (isa<loc::ConcreteInt>(L)) {
203 if (!BT_call_null)
204 BT_call_null =
205 new BuiltinBug("Called function pointer is null (null dereference)");
206 EmitBadCall(BT_call_null, C, CE);
Ted Kremenek091b5882010-03-18 02:17:27 +0000207 }
208
Zhongxing Xu8958fff2009-11-03 06:46:03 +0000209 for (CallExpr::const_arg_iterator I = CE->arg_begin(), E = CE->arg_end();
Ted Kremenek81337162010-03-18 03:22:29 +0000210 I != E; ++I)
211 if (PreVisitProcessArg(C, *I,
Ted Kremenek818b4332010-09-09 22:51:55 +0000212 "Function call argument is an uninitialized value",
213 BT_call_arg))
Ted Kremenek81337162010-03-18 03:22:29 +0000214 return;
Ted Kremenek64fa8582009-11-21 00:49:41 +0000215}
216
Zhongxing Xud02174c2009-11-24 04:45:44 +0000217void CallAndMessageChecker::PreVisitObjCMessageExpr(CheckerContext &C,
218 const ObjCMessageExpr *ME) {
Ted Kremenek64fa8582009-11-21 00:49:41 +0000219
Ted Kremenek64fa8582009-11-21 00:49:41 +0000220 const GRState *state = C.getState();
Ted Kremenekc79d7d42009-11-21 01:25:37 +0000221
Douglas Gregor04badcf2010-04-21 00:45:42 +0000222 // FIXME: Handle 'super'?
223 if (const Expr *receiver = ME->getInstanceReceiver())
Ted Kremenek13976632010-02-08 16:18:51 +0000224 if (state->getSVal(receiver).isUndef()) {
Ted Kremenekd048c6e2010-12-20 21:19:09 +0000225 if (ExplodedNode *N = C.generateSink()) {
Ted Kremenekc79d7d42009-11-21 01:25:37 +0000226 if (!BT_msg_undef)
227 BT_msg_undef =
Ted Kremenek818b4332010-09-09 22:51:55 +0000228 new BuiltinBug("Receiver in message expression is an uninitialized value");
Ted Kremenekc79d7d42009-11-21 01:25:37 +0000229 EnhancedBugReport *R =
230 new EnhancedBugReport(*BT_msg_undef, BT_msg_undef->getName(), N);
231 R->addRange(receiver->getSourceRange());
232 R->addVisitorCreator(bugreporter::registerTrackNullOrUndefValue,
233 receiver);
234 C.EmitReport(R);
235 }
236 return;
237 }
238
239 // Check for any arguments that are uninitialized/undefined.
Zhongxing Xu2055eff2009-11-24 07:06:39 +0000240 for (ObjCMessageExpr::const_arg_iterator I = ME->arg_begin(),
Ted Kremenek81337162010-03-18 03:22:29 +0000241 E = ME->arg_end(); I != E; ++I)
242 if (PreVisitProcessArg(C, *I,
Ted Kremenek818b4332010-09-09 22:51:55 +0000243 "Argument in message expression "
244 "is an uninitialized value", BT_msg_arg))
Ted Kremenek64fa8582009-11-21 00:49:41 +0000245 return;
Zhongxing Xua46e4d92009-12-02 05:49:12 +0000246}
Zhongxing Xu2055eff2009-11-24 07:06:39 +0000247
Ted Kremenek9c149532010-12-01 21:57:22 +0000248bool CallAndMessageChecker::evalNilReceiver(CheckerContext &C,
Zhongxing Xua46e4d92009-12-02 05:49:12 +0000249 const ObjCMessageExpr *ME) {
250 HandleNilReceiver(C, C.getState(), ME);
251 return true; // Nil receiver is not handled elsewhere.
Ted Kremenekfee96e02009-11-24 21:41:28 +0000252}
253
Ted Kremenekc8413fd2010-12-02 07:49:45 +0000254void CallAndMessageChecker::emitNilReceiverBug(CheckerContext &C,
Ted Kremenekfee96e02009-11-24 21:41:28 +0000255 const ObjCMessageExpr *ME,
256 ExplodedNode *N) {
Ted Kremenek091b5882010-03-18 02:17:27 +0000257
Ted Kremenekfee96e02009-11-24 21:41:28 +0000258 if (!BT_msg_ret)
259 BT_msg_ret =
260 new BuiltinBug("Receiver in message expression is "
261 "'nil' and returns a garbage value");
Ted Kremenek091b5882010-03-18 02:17:27 +0000262
Ted Kremenekfee96e02009-11-24 21:41:28 +0000263 llvm::SmallString<200> buf;
264 llvm::raw_svector_ostream os(buf);
265 os << "The receiver of message '" << ME->getSelector().getAsString()
266 << "' is nil and returns a value of type '"
267 << ME->getType().getAsString() << "' that will be garbage";
Ted Kremenek091b5882010-03-18 02:17:27 +0000268
Ted Kremenekfee96e02009-11-24 21:41:28 +0000269 EnhancedBugReport *report = new EnhancedBugReport(*BT_msg_ret, os.str(), N);
Douglas Gregor04badcf2010-04-21 00:45:42 +0000270 if (const Expr *receiver = ME->getInstanceReceiver()) {
271 report->addRange(receiver->getSourceRange());
272 report->addVisitorCreator(bugreporter::registerTrackNullOrUndefValue,
273 receiver);
274 }
Ted Kremenek091b5882010-03-18 02:17:27 +0000275 C.EmitReport(report);
Ted Kremenekfee96e02009-11-24 21:41:28 +0000276}
277
Ted Kremenekc8413fd2010-12-02 07:49:45 +0000278static bool supportsNilWithFloatRet(const llvm::Triple &triple) {
Ted Kremenekf81330c2009-11-24 22:48:18 +0000279 return triple.getVendor() == llvm::Triple::Apple &&
Ted Kremenek61238742010-09-30 00:37:10 +0000280 (triple.getDarwinMajorNumber() >= 9 ||
281 triple.getArch() == llvm::Triple::arm ||
282 triple.getArch() == llvm::Triple::thumb);
Ted Kremenekf81330c2009-11-24 22:48:18 +0000283}
284
Ted Kremenekfee96e02009-11-24 21:41:28 +0000285void CallAndMessageChecker::HandleNilReceiver(CheckerContext &C,
286 const GRState *state,
287 const ObjCMessageExpr *ME) {
Ted Kremenek091b5882010-03-18 02:17:27 +0000288
Ted Kremenekfee96e02009-11-24 21:41:28 +0000289 // Check the return type of the message expression. A message to nil will
290 // return different values depending on the return type and the architecture.
291 QualType RetTy = ME->getType();
Ted Kremenek091b5882010-03-18 02:17:27 +0000292
Ted Kremenekf81330c2009-11-24 22:48:18 +0000293 ASTContext &Ctx = C.getASTContext();
294 CanQualType CanRetTy = Ctx.getCanonicalType(RetTy);
Ted Kremenekfee96e02009-11-24 21:41:28 +0000295
Douglas Gregorfb87b892010-04-26 21:31:17 +0000296 if (CanRetTy->isStructureOrClassType()) {
Ted Kremenekfee96e02009-11-24 21:41:28 +0000297 // FIXME: At some point we shouldn't rely on isConsumedExpr(), but instead
298 // have the "use of undefined value" be smarter about where the
299 // undefined value came from.
300 if (C.getPredecessor()->getParentMap().isConsumedExpr(ME)) {
Ted Kremenekd048c6e2010-12-20 21:19:09 +0000301 if (ExplodedNode* N = C.generateSink(state))
Ted Kremenekc8413fd2010-12-02 07:49:45 +0000302 emitNilReceiverBug(C, ME, N);
Ted Kremenekfee96e02009-11-24 21:41:28 +0000303 return;
304 }
305
306 // The result is not consumed by a surrounding expression. Just propagate
307 // the current state.
308 C.addTransition(state);
309 return;
310 }
311
312 // Other cases: check if the return type is smaller than void*.
Ted Kremenekf81330c2009-11-24 22:48:18 +0000313 if (CanRetTy != Ctx.VoidTy &&
Ted Kremenekfee96e02009-11-24 21:41:28 +0000314 C.getPredecessor()->getParentMap().isConsumedExpr(ME)) {
315 // Compute: sizeof(void *) and sizeof(return type)
Ted Kremenek091b5882010-03-18 02:17:27 +0000316 const uint64_t voidPtrSize = Ctx.getTypeSize(Ctx.VoidPtrTy);
Ted Kremenekf81330c2009-11-24 22:48:18 +0000317 const uint64_t returnTypeSize = Ctx.getTypeSize(CanRetTy);
Ted Kremenekfee96e02009-11-24 21:41:28 +0000318
Ted Kremenekf81330c2009-11-24 22:48:18 +0000319 if (voidPtrSize < returnTypeSize &&
Ted Kremenekc8413fd2010-12-02 07:49:45 +0000320 !(supportsNilWithFloatRet(Ctx.Target.getTriple()) &&
Ted Kremenekf81330c2009-11-24 22:48:18 +0000321 (Ctx.FloatTy == CanRetTy ||
322 Ctx.DoubleTy == CanRetTy ||
323 Ctx.LongDoubleTy == CanRetTy ||
Ted Kremenek61238742010-09-30 00:37:10 +0000324 Ctx.LongLongTy == CanRetTy ||
325 Ctx.UnsignedLongLongTy == CanRetTy))) {
Ted Kremenekd048c6e2010-12-20 21:19:09 +0000326 if (ExplodedNode* N = C.generateSink(state))
Ted Kremenekc8413fd2010-12-02 07:49:45 +0000327 emitNilReceiverBug(C, ME, N);
Ted Kremenekfee96e02009-11-24 21:41:28 +0000328 return;
329 }
330
331 // Handle the safe cases where the return value is 0 if the
332 // receiver is nil.
333 //
334 // FIXME: For now take the conservative approach that we only
335 // return null values if we *know* that the receiver is nil.
336 // This is because we can have surprises like:
337 //
338 // ... = [[NSScreens screens] objectAtIndex:0];
339 //
340 // What can happen is that [... screens] could return nil, but
341 // it most likely isn't nil. We should assume the semantics
342 // of this case unless we have *a lot* more knowledge.
343 //
Ted Kremenekc8413fd2010-12-02 07:49:45 +0000344 SVal V = C.getSValBuilder().makeZeroVal(ME->getType());
Ted Kremenekd048c6e2010-12-20 21:19:09 +0000345 C.generateNode(state->BindExpr(ME, V));
Ted Kremenekfee96e02009-11-24 21:41:28 +0000346 return;
347 }
Ted Kremenek091b5882010-03-18 02:17:27 +0000348
Ted Kremenekfee96e02009-11-24 21:41:28 +0000349 C.addTransition(state);
Zhongxing Xu8958fff2009-11-03 06:46:03 +0000350}