blob: e269f46422210f75a7f487dc9b2ac45b8448c867 [file] [log] [blame]
Anna Zaks31f69cc2012-09-29 00:20:38 +00001//=- IvarInvalidationChecker.cpp - -*- C++ -------------------------------*-==//
Anna Zaks5bf5c2e2012-09-26 18:55:16 +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//
10// This checker implements annotation driven invalidation checking. If a class
11// contains a method annotated with 'objc_instance_variable_invalidator',
12// - (void) foo
13// __attribute__((annotate("objc_instance_variable_invalidator")));
14// all the "ivalidatable" instance variables of this class should be
15// invalidated. We call an instance variable ivalidatable if it is an object of
Anna Zaks31f69cc2012-09-29 00:20:38 +000016// a class which contains an invalidation method. There could be multiple
17// methods annotated with such annotations per class, either one can be used
18// to invalidate the ivar. An ivar or property are considered to be
19// invalidated if they are being assigned 'nil' or an invalidation method has
20// been called on them. An invalidation method should either invalidate all
21// the ivars or call another invalidation method (on self).
Anna Zaks5bf5c2e2012-09-26 18:55:16 +000022//
23//===----------------------------------------------------------------------===//
24
25#include "ClangSACheckers.h"
26#include "clang/StaticAnalyzer/Core/Checker.h"
27#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
28#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
29#include "clang/AST/DeclObjC.h"
30#include "clang/AST/StmtVisitor.h"
31#include "llvm/ADT/DenseMap.h"
32#include "llvm/ADT/SmallString.h"
33
34using namespace clang;
35using namespace ento;
36
37namespace {
38class IvarInvalidationChecker :
39 public Checker<check::ASTDecl<ObjCMethodDecl> > {
40
Anna Zaks31f69cc2012-09-29 00:20:38 +000041 typedef llvm::DenseSet<const ObjCMethodDecl*> MethodSet;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +000042 typedef llvm::DenseMap<const ObjCMethodDecl*,
43 const ObjCIvarDecl*> MethToIvarMapTy;
44 typedef llvm::DenseMap<const ObjCPropertyDecl*,
45 const ObjCIvarDecl*> PropToIvarMapTy;
Anna Zaks377945c2012-09-27 21:57:14 +000046 typedef llvm::DenseMap<const ObjCIvarDecl*,
47 const ObjCPropertyDecl*> IvarToPropMapTy;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +000048
Anna Zaks31f69cc2012-09-29 00:20:38 +000049
50 struct IvarInfo {
51 /// Has the ivar been invalidated?
52 bool IsInvalidated;
53
54 /// The methods which can be used to invalidate the ivar.
55 MethodSet InvalidationMethods;
56
57 IvarInfo() : IsInvalidated(false) {}
58 void addInvalidationMethod(const ObjCMethodDecl *MD) {
59 InvalidationMethods.insert(MD);
60 }
61
62 bool needsInvalidation() const {
63 return !InvalidationMethods.empty();
64 }
65
66 void markInvalidated() {
67 IsInvalidated = true;
68 }
69
70 bool markInvalidated(const ObjCMethodDecl *MD) {
71 if (IsInvalidated)
72 return true;
73 for (MethodSet::iterator I = InvalidationMethods.begin(),
74 E = InvalidationMethods.end(); I != E; ++I) {
75 if (*I == MD) {
76 IsInvalidated = true;
77 return true;
78 }
79 }
80 return false;
81 }
82
83 bool isInvalidated() const {
84 return IsInvalidated;
85 }
86 };
87
88 typedef llvm::DenseMap<const ObjCIvarDecl*, IvarInfo> IvarSet;
89
Anna Zaks5bf5c2e2012-09-26 18:55:16 +000090 /// Statement visitor, which walks the method body and flags the ivars
91 /// referenced in it (either directly or via property).
92 class MethodCrawler : public ConstStmtVisitor<MethodCrawler> {
Anna Zaks31f69cc2012-09-29 00:20:38 +000093 const ObjCMethodDecl *EnclosingMethod;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +000094
95 /// The set of Ivars which need to be invalidated.
96 IvarSet &IVars;
97
Anna Zaks31f69cc2012-09-29 00:20:38 +000098 /// Flag is set as the result of a message send to another
99 /// invalidation method.
100 bool &CalledAnotherInvalidationMethod;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000101
Anna Zaks31f69cc2012-09-29 00:20:38 +0000102 /// Property setter to ivar mapping.
103 const MethToIvarMapTy &PropertySetterToIvarMap;
104
105 /// Property getter to ivar mapping.
106 const MethToIvarMapTy &PropertyGetterToIvarMap;
107
108 /// Property to ivar mapping.
109 const PropToIvarMapTy &PropertyToIvarMap;
110
111 /// The invalidation method being currently processed.
112 const ObjCMethodDecl *InvalidationMethod;
113
114 /// Peel off parents, casts, OpaqueValueExpr, and PseudoObjectExpr.
115 const Expr *peel(const Expr *E) const;
116
117 /// Does this expression represent zero: '0'?
118 bool isZero(const Expr *E) const;
119
120 /// Mark the given ivar as invalidated.
121 void markInvalidated(const ObjCIvarDecl *Iv);
122
123 /// Checks if IvarRef refers to the tracked IVar, if yes, marks it as
124 /// invalidated.
125 void checkObjCIvarRefExpr(const ObjCIvarRefExpr *IvarRef);
126
127 /// Checks if ObjCPropertyRefExpr refers to the tracked IVar, if yes, marks
128 /// it as invalidated.
129 void checkObjCPropertyRefExpr(const ObjCPropertyRefExpr *PA);
130
131 /// Checks if ObjCMessageExpr refers to (is a getter for) the tracked IVar,
132 /// if yes, marks it as invalidated.
133 void checkObjCMessageExpr(const ObjCMessageExpr *ME);
134
135 /// Checks if the Expr refers to an ivar, if yes, marks it as invalidated.
136 void check(const Expr *E);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000137
138 public:
Anna Zaks31f69cc2012-09-29 00:20:38 +0000139 MethodCrawler(const ObjCMethodDecl *InMeth,
Anna Zaks377945c2012-09-27 21:57:14 +0000140 IvarSet &InIVars,
Anna Zaks31f69cc2012-09-29 00:20:38 +0000141 bool &InCalledAnotherInvalidationMethod,
142 const MethToIvarMapTy &InPropertySetterToIvarMap,
143 const MethToIvarMapTy &InPropertyGetterToIvarMap,
144 const PropToIvarMapTy &InPropertyToIvarMap)
145 : EnclosingMethod(InMeth),
146 IVars(InIVars),
147 CalledAnotherInvalidationMethod(InCalledAnotherInvalidationMethod),
148 PropertySetterToIvarMap(InPropertySetterToIvarMap),
149 PropertyGetterToIvarMap(InPropertyGetterToIvarMap),
150 PropertyToIvarMap(InPropertyToIvarMap),
151 InvalidationMethod(0) {}
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000152
153 void VisitStmt(const Stmt *S) { VisitChildren(S); }
154
Anna Zaks31f69cc2012-09-29 00:20:38 +0000155 void VisitBinaryOperator(const BinaryOperator *BO);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000156
157 void VisitObjCMessageExpr(const ObjCMessageExpr *ME);
158
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000159 void VisitChildren(const Stmt *S) {
Anna Zaks31f69cc2012-09-29 00:20:38 +0000160 for (Stmt::const_child_range I = S->children(); I; ++I) {
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000161 if (*I)
Anna Zaksb087bbf2012-09-27 19:45:08 +0000162 this->Visit(*I);
Anna Zaks31f69cc2012-09-29 00:20:38 +0000163 if (CalledAnotherInvalidationMethod)
164 return;
165 }
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000166 }
167 };
168
169 /// Check if the any of the methods inside the interface are annotated with
Anna Zaks31f69cc2012-09-29 00:20:38 +0000170 /// the invalidation annotation, update the IvarInfo accordingly.
171 static void containsInvalidationMethod(const ObjCContainerDecl *D,
172 IvarInfo &Out);
Anna Zaks377945c2012-09-27 21:57:14 +0000173
174 /// Check if ivar should be tracked and add to TrackedIvars if positive.
175 /// Returns true if ivar should be tracked.
176 static bool trackIvar(const ObjCIvarDecl *Iv, IvarSet &TrackedIvars);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000177
178 /// Given the property declaration, and the list of tracked ivars, finds
179 /// the ivar backing the property when possible. Returns '0' when no such
180 /// ivar could be found.
181 static const ObjCIvarDecl *findPropertyBackingIvar(
182 const ObjCPropertyDecl *Prop,
183 const ObjCInterfaceDecl *InterfaceD,
Anna Zaks377945c2012-09-27 21:57:14 +0000184 IvarSet &TrackedIvars);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000185
186public:
187 void checkASTDecl(const ObjCMethodDecl *D, AnalysisManager& Mgr,
188 BugReporter &BR) const;
189
Anna Zaksb087bbf2012-09-27 19:45:08 +0000190 // TODO: We are currently ignoring the ivars coming from class extensions.
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000191};
192
Anna Zaks31f69cc2012-09-29 00:20:38 +0000193static bool isInvalidationMethod(const ObjCMethodDecl *M) {
Anna Zaksb087bbf2012-09-27 19:45:08 +0000194 for (specific_attr_iterator<AnnotateAttr>
195 AI = M->specific_attr_begin<AnnotateAttr>(),
196 AE = M->specific_attr_end<AnnotateAttr>(); AI != AE; ++AI) {
197 const AnnotateAttr *Ann = *AI;
198 if (Ann->getAnnotation() == "objc_instance_variable_invalidator")
199 return true;
200 }
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000201 return false;
202}
203
Anna Zaks31f69cc2012-09-29 00:20:38 +0000204void IvarInvalidationChecker::containsInvalidationMethod(
205 const ObjCContainerDecl *D, IvarInfo &OutInfo) {
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000206
207 // TODO: Cache the results.
208
209 if (!D)
Anna Zaks31f69cc2012-09-29 00:20:38 +0000210 return;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000211
212 // Check all methods.
213 for (ObjCContainerDecl::method_iterator
214 I = D->meth_begin(),
215 E = D->meth_end(); I != E; ++I) {
216 const ObjCMethodDecl *MDI = *I;
217 if (isInvalidationMethod(MDI))
Anna Zaks31f69cc2012-09-29 00:20:38 +0000218 OutInfo.addInvalidationMethod(
219 cast<ObjCMethodDecl>(MDI->getCanonicalDecl()));
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000220 }
221
222 // If interface, check all parent protocols and super.
223 // TODO: Visit all categories in case the invalidation method is declared in
224 // a category.
225 if (const ObjCInterfaceDecl *InterfaceD = dyn_cast<ObjCInterfaceDecl>(D)) {
226 for (ObjCInterfaceDecl::protocol_iterator
227 I = InterfaceD->protocol_begin(),
228 E = InterfaceD->protocol_end(); I != E; ++I) {
Anna Zaks31f69cc2012-09-29 00:20:38 +0000229 containsInvalidationMethod(*I, OutInfo);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000230 }
Anna Zaks31f69cc2012-09-29 00:20:38 +0000231 containsInvalidationMethod(InterfaceD->getSuperClass(), OutInfo);
232 return;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000233 }
234
235 // If protocol, check all parent protocols.
236 if (const ObjCProtocolDecl *ProtD = dyn_cast<ObjCProtocolDecl>(D)) {
237 for (ObjCInterfaceDecl::protocol_iterator
238 I = ProtD->protocol_begin(),
239 E = ProtD->protocol_end(); I != E; ++I) {
Anna Zaks31f69cc2012-09-29 00:20:38 +0000240 containsInvalidationMethod(*I, OutInfo);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000241 }
Anna Zaks31f69cc2012-09-29 00:20:38 +0000242 return;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000243 }
244
245 llvm_unreachable("One of the casts above should have succeeded.");
246}
247
Anna Zaks377945c2012-09-27 21:57:14 +0000248bool IvarInvalidationChecker::trackIvar(const ObjCIvarDecl *Iv,
249 IvarSet &TrackedIvars) {
250 QualType IvQTy = Iv->getType();
251 const ObjCObjectPointerType *IvTy = IvQTy->getAs<ObjCObjectPointerType>();
252 if (!IvTy)
253 return false;
254 const ObjCInterfaceDecl *IvInterf = IvTy->getInterfaceDecl();
Anna Zaks31f69cc2012-09-29 00:20:38 +0000255
256 IvarInfo Info;
257 containsInvalidationMethod(IvInterf, Info);
258 if (Info.needsInvalidation()) {
259 TrackedIvars[cast<ObjCIvarDecl>(Iv->getCanonicalDecl())] = Info;
Anna Zaks377945c2012-09-27 21:57:14 +0000260 return true;
261 }
262 return false;
263}
264
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000265const ObjCIvarDecl *IvarInvalidationChecker::findPropertyBackingIvar(
266 const ObjCPropertyDecl *Prop,
267 const ObjCInterfaceDecl *InterfaceD,
Anna Zaks377945c2012-09-27 21:57:14 +0000268 IvarSet &TrackedIvars) {
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000269 const ObjCIvarDecl *IvarD = 0;
270
271 // Lookup for the synthesized case.
272 IvarD = Prop->getPropertyIvarDecl();
Anna Zaks377945c2012-09-27 21:57:14 +0000273 if (IvarD) {
274 if (TrackedIvars.count(IvarD)) {
275 return IvarD;
276 }
277 // If the ivar is synthesized we still want to track it.
278 if (trackIvar(IvarD, TrackedIvars))
279 return IvarD;
280 }
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000281
282 // Lookup IVars named "_PropName"or "PropName" among the tracked Ivars.
283 StringRef PropName = Prop->getIdentifier()->getName();
284 for (IvarSet::const_iterator I = TrackedIvars.begin(),
285 E = TrackedIvars.end(); I != E; ++I) {
286 const ObjCIvarDecl *Iv = I->first;
287 StringRef IvarName = Iv->getName();
288
289 if (IvarName == PropName)
290 return Iv;
291
292 SmallString<128> PropNameWithUnderscore;
293 {
294 llvm::raw_svector_ostream os(PropNameWithUnderscore);
295 os << '_' << PropName;
296 }
297 if (IvarName == PropNameWithUnderscore.str())
298 return Iv;
299 }
300
301 // Note, this is a possible source of false positives. We could look at the
302 // getter implementation to find the ivar when its name is not derived from
303 // the property name.
304 return 0;
305}
306
307void IvarInvalidationChecker::checkASTDecl(const ObjCMethodDecl *D,
308 AnalysisManager& Mgr,
309 BugReporter &BR) const {
310 // We are only interested in checking the cleanup methods.
311 if (!D->hasBody() || !isInvalidationMethod(D))
312 return;
313
314 // Collect all ivars that need cleanup.
315 IvarSet Ivars;
316 const ObjCInterfaceDecl *InterfaceD = D->getClassInterface();
317 for (ObjCInterfaceDecl::ivar_iterator
318 II = InterfaceD->ivar_begin(),
319 IE = InterfaceD->ivar_end(); II != IE; ++II) {
320 const ObjCIvarDecl *Iv = *II;
Anna Zaks377945c2012-09-27 21:57:14 +0000321 trackIvar(Iv, Ivars);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000322 }
323
Anna Zaks377945c2012-09-27 21:57:14 +0000324 // Construct Property/Property Accessor to Ivar maps to assist checking if an
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000325 // ivar which is backing a property has been reset.
Anna Zaks31f69cc2012-09-29 00:20:38 +0000326 MethToIvarMapTy PropSetterToIvarMap;
327 MethToIvarMapTy PropGetterToIvarMap;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000328 PropToIvarMapTy PropertyToIvarMap;
Anna Zaks377945c2012-09-27 21:57:14 +0000329 IvarToPropMapTy IvarToPopertyMap;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000330 for (ObjCInterfaceDecl::prop_iterator
331 I = InterfaceD->prop_begin(),
332 E = InterfaceD->prop_end(); I != E; ++I) {
333 const ObjCPropertyDecl *PD = *I;
334
335 const ObjCIvarDecl *ID = findPropertyBackingIvar(PD, InterfaceD, Ivars);
336 if (!ID) {
337 continue;
338 }
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000339
340 // Store the mappings.
341 PD = cast<ObjCPropertyDecl>(PD->getCanonicalDecl());
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000342 PropertyToIvarMap[PD] = ID;
Anna Zaks377945c2012-09-27 21:57:14 +0000343 IvarToPopertyMap[ID] = PD;
344
345 // Find the setter and the getter.
346 const ObjCMethodDecl *SetterD = PD->getSetterMethodDecl();
347 if (SetterD) {
348 SetterD = cast<ObjCMethodDecl>(SetterD->getCanonicalDecl());
Anna Zaks31f69cc2012-09-29 00:20:38 +0000349 PropSetterToIvarMap[SetterD] = ID;
Anna Zaks377945c2012-09-27 21:57:14 +0000350 }
351
352 const ObjCMethodDecl *GetterD = PD->getGetterMethodDecl();
353 if (GetterD) {
354 GetterD = cast<ObjCMethodDecl>(GetterD->getCanonicalDecl());
Anna Zaks31f69cc2012-09-29 00:20:38 +0000355 PropGetterToIvarMap[GetterD] = ID;
Anna Zaks377945c2012-09-27 21:57:14 +0000356 }
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000357 }
358
359
Anna Zaks31f69cc2012-09-29 00:20:38 +0000360 // Check which ivars have been invalidated in the method body.
361 bool CalledAnotherInvalidationMethod = false;
362 MethodCrawler(D, Ivars,
363 CalledAnotherInvalidationMethod,
364 PropSetterToIvarMap,
365 PropGetterToIvarMap,
366 PropertyToIvarMap).VisitStmt(D->getBody());
367
368 if (CalledAnotherInvalidationMethod)
369 return;
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000370
371 // Warn on the ivars that were not accessed by the method.
372 for (IvarSet::const_iterator I = Ivars.begin(), E = Ivars.end(); I != E; ++I){
Anna Zaks31f69cc2012-09-29 00:20:38 +0000373 if (!I->second.isInvalidated()) {
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000374 const ObjCIvarDecl *IvarDecl = I->first;
375
376 PathDiagnosticLocation IvarDecLocation =
Anna Zaksb087bbf2012-09-27 19:45:08 +0000377 PathDiagnosticLocation::createEnd(D->getBody(), BR.getSourceManager(),
378 Mgr.getAnalysisDeclContext(D));
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000379
380 SmallString<128> sbuf;
381 llvm::raw_svector_ostream os(sbuf);
Anna Zaks377945c2012-09-27 21:57:14 +0000382
383 // Construct the warning message.
384 if (IvarDecl->getSynthesize()) {
385 const ObjCPropertyDecl *PD = IvarToPopertyMap[IvarDecl];
386 assert(PD &&
387 "Do we synthesize ivars for something other than properties?");
388 os << "Property "<< PD->getName() << " needs to be invalidated";
389 } else {
390 os << "Instance variable "<< IvarDecl->getName()
391 << " needs to be invalidated";
392 }
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000393
Anna Zaksb087bbf2012-09-27 19:45:08 +0000394 BR.EmitBasicReport(D,
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000395 "Incomplete invalidation",
396 categories::CoreFoundationObjectiveC, os.str(),
397 IvarDecLocation);
398 }
399 }
400}
401
Anna Zaks31f69cc2012-09-29 00:20:38 +0000402void IvarInvalidationChecker::MethodCrawler::markInvalidated(
403 const ObjCIvarDecl *Iv) {
404 IvarSet::iterator I = IVars.find(Iv);
405 if (I != IVars.end()) {
406 // If InvalidationMethod is present, we are processing the message send and
407 // should ensure we are invalidating with the appropriate method,
408 // otherwise, we are processing setting to 'nil'.
409 if (InvalidationMethod)
410 I->second.markInvalidated(InvalidationMethod);
411 else
412 I->second.markInvalidated();
413 }
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000414}
415
Anna Zaks31f69cc2012-09-29 00:20:38 +0000416const Expr *IvarInvalidationChecker::MethodCrawler::peel(const Expr *E) const {
417 E = E->IgnoreParenCasts();
418 if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
419 E = POE->getSyntacticForm()->IgnoreParenCasts();
420 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
421 E = OVE->getSourceExpr()->IgnoreParenCasts();
422 return E;
423}
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000424
Anna Zaks31f69cc2012-09-29 00:20:38 +0000425void IvarInvalidationChecker::MethodCrawler::checkObjCIvarRefExpr(
426 const ObjCIvarRefExpr *IvarRef) {
427 if (const Decl *D = IvarRef->getDecl())
428 markInvalidated(cast<ObjCIvarDecl>(D->getCanonicalDecl()));
429}
430
431void IvarInvalidationChecker::MethodCrawler::checkObjCMessageExpr(
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000432 const ObjCMessageExpr *ME) {
433 const ObjCMethodDecl *MD = ME->getMethodDecl();
434 if (MD) {
435 MD = cast<ObjCMethodDecl>(MD->getCanonicalDecl());
Anna Zaks31f69cc2012-09-29 00:20:38 +0000436 MethToIvarMapTy::const_iterator IvI = PropertyGetterToIvarMap.find(MD);
437 if (IvI != PropertyGetterToIvarMap.end())
438 markInvalidated(IvI->second);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000439 }
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000440}
441
Anna Zaks31f69cc2012-09-29 00:20:38 +0000442void IvarInvalidationChecker::MethodCrawler::checkObjCPropertyRefExpr(
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000443 const ObjCPropertyRefExpr *PA) {
444
445 if (PA->isExplicitProperty()) {
446 const ObjCPropertyDecl *PD = PA->getExplicitProperty();
447 if (PD) {
448 PD = cast<ObjCPropertyDecl>(PD->getCanonicalDecl());
Anna Zaks31f69cc2012-09-29 00:20:38 +0000449 PropToIvarMapTy::const_iterator IvI = PropertyToIvarMap.find(PD);
450 if (IvI != PropertyToIvarMap.end())
451 markInvalidated(IvI->second);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000452 return;
453 }
454 }
455
456 if (PA->isImplicitProperty()) {
457 const ObjCMethodDecl *MD = PA->getImplicitPropertySetter();
458 if (MD) {
459 MD = cast<ObjCMethodDecl>(MD->getCanonicalDecl());
Anna Zaks31f69cc2012-09-29 00:20:38 +0000460 MethToIvarMapTy::const_iterator IvI =PropertyGetterToIvarMap.find(MD);
461 if (IvI != PropertyGetterToIvarMap.end())
462 markInvalidated(IvI->second);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000463 return;
464 }
465 }
Anna Zaks31f69cc2012-09-29 00:20:38 +0000466}
467
468bool IvarInvalidationChecker::MethodCrawler::isZero(const Expr *E) const {
469 E = peel(E);
470 if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
471 return IL->getValue() == 0;
472
473 if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
474 return ICE->getCastKind() == CK_NullToPointer;
475
476 return false;
477}
478
479void IvarInvalidationChecker::MethodCrawler::check(const Expr *E) {
480 E = peel(E);
481
482 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
483 E = OVE->getSourceExpr();
484
485 if (const ObjCIvarRefExpr *IvarRef = dyn_cast<ObjCIvarRefExpr>(E)) {
486 checkObjCIvarRefExpr(IvarRef);
487 return;
488 }
489
490 if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E)) {
491 checkObjCPropertyRefExpr(PropRef);
492 return;
493 }
494
495 if (const ObjCMessageExpr *MsgExpr = dyn_cast<ObjCMessageExpr>(E)) {
496 checkObjCMessageExpr(MsgExpr);
497 return;
498 }
499}
500
501void IvarInvalidationChecker::MethodCrawler::VisitBinaryOperator(
502 const BinaryOperator *BO) {
503 if (!BO->isAssignmentOp())
504 return;
505
506 // Do we assign zero?
507 if (!isZero(BO->getRHS()))
508 return;
509
510 // Check the variable we are assigning to.
511 check(BO->getLHS());
512
513 VisitStmt(BO);
514}
515
516void IvarInvalidationChecker::MethodCrawler::VisitObjCMessageExpr(
517 const ObjCMessageExpr *ME) {
518 const ObjCMethodDecl *MD = ME->getMethodDecl();
519 const Expr *Receiver = ME->getInstanceReceiver();
520
521 // Stop if we are calling '[self invalidate]'.
522 if (Receiver && isInvalidationMethod(MD))
523 if (const DeclRefExpr *RD =
524 dyn_cast<DeclRefExpr>(Receiver->IgnoreParenCasts())) {
525 if (RD->getDecl() == EnclosingMethod->getSelfDecl()) {
526 CalledAnotherInvalidationMethod = true;
527 return;
528 }
529 }
530
531 // Check if we call a setter and set the property to 'nil'.
532 if (MD && (ME->getNumArgs() == 1) && isZero(ME->getArg(0))) {
533 MD = cast<ObjCMethodDecl>(MD->getCanonicalDecl());
534 MethToIvarMapTy::const_iterator IvI = PropertySetterToIvarMap.find(MD);
535 if (IvI != PropertySetterToIvarMap.end()) {
536 markInvalidated(IvI->second);
537 return;
538 }
539 }
540
541 // Check if we call the 'invalidation' routine on the ivar.
542 if (Receiver) {
543 InvalidationMethod = MD;
544 check(Receiver->IgnoreParenCasts());
545 InvalidationMethod = 0;
546 }
547
548 VisitStmt(ME);
Anna Zaks5bf5c2e2012-09-26 18:55:16 +0000549}
550}
551
552// Register the checker.
553void ento::registerIvarInvalidationChecker(CheckerManager &mgr) {
554 mgr.registerChecker<IvarInvalidationChecker>();
555}