1 //===--- CallAndMessageChecker.cpp ------------------------------*- C++ -*--==//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This defines CallAndMessageChecker, a builtin checker that checks for various
11 // errors of call and objc message expressions.
13 //===----------------------------------------------------------------------===//
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"
24 using namespace clang;
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;
38 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
39 void checkPreObjCMessage(ObjCMessage msg, CheckerContext &C) const;
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);
47 static void EmitBadCall(BugType *BT, CheckerContext &C, const CallExpr *CE);
48 void emitNilReceiverBug(CheckerContext &C, const ObjCMessage &msg,
49 ExplodedNode *N) const;
51 void HandleNilReceiver(CheckerContext &C,
52 const ProgramState *state,
53 ObjCMessage msg) const;
55 static void LazyInit_BT(const char *desc, llvm::OwningPtr<BugType> &BT) {
57 BT.reset(new BuiltinBug(desc));
60 } // end anonymous namespace
62 void CallAndMessageChecker::EmitBadCall(BugType *BT, CheckerContext &C,
64 ExplodedNode *N = C.generateSink();
68 BugReport *R = new BugReport(*BT, BT->getName(), N);
69 R->addVisitor(bugreporter::getTrackNullOrUndefValueVisitor(N,
70 bugreporter::GetCalleeExpr(N)));
74 void CallAndMessageChecker::PreVisitProcessArgs(CheckerContext &C,
75 CallOrObjCMessage callOrMsg,
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),
85 bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C,
86 SVal V, SourceRange argRange,
89 llvm::OwningPtr<BugType> &BT) {
92 if (ExplodedNode *N = C.generateSink()) {
93 LazyInit_BT(BT_desc, BT);
95 // Generate a report for this bug.
96 BugReport *R = new BugReport(*BT, BT->getName(), N);
97 R->addRange(argRange);
99 R->addVisitor(bugreporter::getTrackNullOrUndefValueVisitor(N, argEx));
105 if (const nonloc::LazyCompoundVal *LV =
106 dyn_cast<nonloc::LazyCompoundVal>(&V)) {
108 class FindUninitializedField {
110 SmallVector<const FieldDecl *, 10> FieldChain;
113 StoreManager &StoreMgr;
114 MemRegionManager &MrMgr;
117 FindUninitializedField(ASTContext &c, StoreManager &storeMgr,
118 MemRegionManager &mrMgr, Store s)
119 : C(c), StoreMgr(storeMgr), MrMgr(mrMgr), store(s) {}
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);
131 if (T->getAsStructureType()) {
136 const SVal &V = StoreMgr.Retrieve(store, loc::MemRegionVal(FR));
140 FieldChain.pop_back();
148 const LazyCompoundValData *D = LV->getCVData();
149 FindUninitializedField F(C.getASTContext(),
150 C.getState()->getStateManager().getStoreManager(),
151 C.getSValBuilder().getRegionManager(),
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";
161 if (F.FieldChain.size() == 1)
162 os << " (e.g., field: '" << *F.FieldChain[0] << "')";
164 os << " (e.g., via the field chain: '";
166 for (SmallVectorImpl<const FieldDecl *>::iterator
167 DI = F.FieldChain.begin(), DE = F.FieldChain.end(); DI!=DE;++DI){
177 // Generate a report for this bug.
178 BugReport *R = new BugReport(*BT, os.str(), N);
179 R->addRange(argRange);
181 // FIXME: enhance track back for uninitialized value for arbitrary
192 void CallAndMessageChecker::checkPreStmt(const CallExpr *CE,
193 CheckerContext &C) const{
195 const Expr *Callee = CE->getCallee()->IgnoreParens();
196 SVal L = C.getState()->getSVal(Callee);
200 BT_call_undef.reset(new BuiltinBug("Called function pointer is an "
201 "uninitalized pointer value"));
202 EmitBadCall(BT_call_undef.get(), C, CE);
206 if (isa<loc::ConcreteInt>(L)) {
209 new BuiltinBug("Called function pointer is null (null dereference)"));
210 EmitBadCall(BT_call_null.get(), C, CE);
213 PreVisitProcessArgs(C, CallOrObjCMessage(CE, C.getState()),
214 "Function call argument is an uninitialized value",
218 void CallAndMessageChecker::checkPreObjCMessage(ObjCMessage msg,
219 CheckerContext &C) const {
221 const ProgramState *state = C.getState();
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()) {
229 BT_msg_undef.reset(new BuiltinBug("Receiver in message expression is "
230 "an uninitialized value"));
232 new BugReport(*BT_msg_undef, BT_msg_undef->getName(), N);
233 R->addRange(receiver->getSourceRange());
234 R->addVisitor(bugreporter::getTrackNullOrUndefValueVisitor(N,
240 // Bifurcate the state into nil and non-nil ones.
241 DefinedOrUnknownSVal receiverVal = cast<DefinedOrUnknownSVal>(recVal);
243 const ProgramState *notNilState, *nilState;
244 llvm::tie(notNilState, nilState) = state->assume(receiverVal);
246 // Handle receiver must be nil.
247 if (nilState && !notNilState) {
248 HandleNilReceiver(C, state, msg);
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);
261 void CallAndMessageChecker::emitNilReceiverBug(CheckerContext &C,
262 const ObjCMessage &msg,
263 ExplodedNode *N) const {
267 new BuiltinBug("Receiver in message expression is "
268 "'nil' and returns a garbage value"));
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";
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,
282 C.EmitReport(report);
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);
292 void CallAndMessageChecker::HandleNilReceiver(CheckerContext &C,
293 const ProgramState *state,
294 ObjCMessage msg) const {
295 ASTContext &Ctx = C.getASTContext();
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);
301 CanQualType CanRetTy = Ctx.getCanonicalType(RetTy);
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);
313 // The result is not consumed by a surrounding expression. Just propagate
314 // the current state.
315 C.addTransition(state);
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);
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);
338 // Handle the safe cases where the return value is 0 if the
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:
345 // ... = [[NSScreens screens] objectAtIndex:0];
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.
351 SVal V = C.getSValBuilder().makeZeroVal(msg.getType(Ctx));
352 C.generateNode(state->BindExpr(msg.getOriginExpr(), V));
356 C.addTransition(state);
359 void ento::registerCallAndMessageChecker(CheckerManager &mgr) {
360 mgr.registerChecker<CallAndMessageChecker>();