IvarInvalidationChecker.cpp revision d523df6a143a97eea46916c6e31c8f2a0728bf28 
1//=- IvarInvalidationChecker.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 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
16//  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).
22//
23//  Partial invalidor annotation allows to addess cases when ivars are
24//  invalidated by other methods, which might or might not be called from
25//  the invalidation method. The checker checks that each invalidation
26//  method and all the partial methods cumulatively invalidate all ivars.
27//    __attribute__((annotate("objc_instance_variable_invalidator_partial")));
28//
29//===----------------------------------------------------------------------===//
30
31#include "ClangSACheckers.h"
32#include "clang/AST/Attr.h"
33#include "clang/AST/DeclObjC.h"
34#include "clang/AST/StmtVisitor.h"
35#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
36#include "clang/StaticAnalyzer/Core/Checker.h"
37#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
38#include "llvm/ADT/DenseMap.h"
39#include "llvm/ADT/SetVector.h"
40#include "llvm/ADT/SmallString.h"
41
42using namespace clang;
43using namespace ento;
44
45namespace {
46
47struct ChecksFilter {
48  /// Check for missing invalidation method declarations.
49  DefaultBool check_MissingInvalidationMethod;
50  /// Check that all ivars are invalidated.
51  DefaultBool check_InstanceVariableInvalidation;
52};
53
54class IvarInvalidationCheckerImpl {
55
56  typedef llvm::SmallSetVector<const ObjCMethodDecl*, 2> MethodSet;
57  typedef llvm::DenseMap<const ObjCMethodDecl*,
58                         const ObjCIvarDecl*> MethToIvarMapTy;
59  typedef llvm::DenseMap<const ObjCPropertyDecl*,
60                         const ObjCIvarDecl*> PropToIvarMapTy;
61  typedef llvm::DenseMap<const ObjCIvarDecl*,
62                         const ObjCPropertyDecl*> IvarToPropMapTy;
63
64
65  struct InvalidationInfo {
66    /// Has the ivar been invalidated?
67    bool IsInvalidated;
68
69    /// The methods which can be used to invalidate the ivar.
70    MethodSet InvalidationMethods;
71
72    InvalidationInfo() : IsInvalidated(false) {}
73    void addInvalidationMethod(const ObjCMethodDecl *MD) {
74      InvalidationMethods.insert(MD);
75    }
76
77    bool needsInvalidation() const {
78      return !InvalidationMethods.empty();
79    }
80
81    bool hasMethod(const ObjCMethodDecl *MD) {
82      if (IsInvalidated)
83        return true;
84      for (MethodSet::iterator I = InvalidationMethods.begin(),
85          E = InvalidationMethods.end(); I != E; ++I) {
86        if (*I == MD) {
87          IsInvalidated = true;
88          return true;
89        }
90      }
91      return false;
92    }
93  };
94
95  typedef llvm::DenseMap<const ObjCIvarDecl*, InvalidationInfo> IvarSet;
96
97  /// Statement visitor, which walks the method body and flags the ivars
98  /// referenced in it (either directly or via property).
99  class MethodCrawler : public ConstStmtVisitor<MethodCrawler> {
100    /// The set of Ivars which need to be invalidated.
101    IvarSet &IVars;
102
103    /// Flag is set as the result of a message send to another
104    /// invalidation method.
105    bool &CalledAnotherInvalidationMethod;
106
107    /// Property setter to ivar mapping.
108    const MethToIvarMapTy &PropertySetterToIvarMap;
109
110    /// Property getter to ivar mapping.
111    const MethToIvarMapTy &PropertyGetterToIvarMap;
112
113    /// Property to ivar mapping.
114    const PropToIvarMapTy &PropertyToIvarMap;
115
116    /// The invalidation method being currently processed.
117    const ObjCMethodDecl *InvalidationMethod;
118
119    ASTContext &Ctx;
120
121    /// Peel off parens, casts, OpaqueValueExpr, and PseudoObjectExpr.
122    const Expr *peel(const Expr *E) const;
123
124    /// Does this expression represent zero: '0'?
125    bool isZero(const Expr *E) const;
126
127    /// Mark the given ivar as invalidated.
128    void markInvalidated(const ObjCIvarDecl *Iv);
129
130    /// Checks if IvarRef refers to the tracked IVar, if yes, marks it as
131    /// invalidated.
132    void checkObjCIvarRefExpr(const ObjCIvarRefExpr *IvarRef);
133
134    /// Checks if ObjCPropertyRefExpr refers to the tracked IVar, if yes, marks
135    /// it as invalidated.
136    void checkObjCPropertyRefExpr(const ObjCPropertyRefExpr *PA);
137
138    /// Checks if ObjCMessageExpr refers to (is a getter for) the tracked IVar,
139    /// if yes, marks it as invalidated.
140    void checkObjCMessageExpr(const ObjCMessageExpr *ME);
141
142    /// Checks if the Expr refers to an ivar, if yes, marks it as invalidated.
143    void check(const Expr *E);
144
145  public:
146    MethodCrawler(IvarSet &InIVars,
147                  bool &InCalledAnotherInvalidationMethod,
148                  const MethToIvarMapTy &InPropertySetterToIvarMap,
149                  const MethToIvarMapTy &InPropertyGetterToIvarMap,
150                  const PropToIvarMapTy &InPropertyToIvarMap,
151                  ASTContext &InCtx)
152    : IVars(InIVars),
153      CalledAnotherInvalidationMethod(InCalledAnotherInvalidationMethod),
154      PropertySetterToIvarMap(InPropertySetterToIvarMap),
155      PropertyGetterToIvarMap(InPropertyGetterToIvarMap),
156      PropertyToIvarMap(InPropertyToIvarMap),
157      InvalidationMethod(0),
158      Ctx(InCtx) {}
159
160    void VisitStmt(const Stmt *S) { VisitChildren(S); }
161
162    void VisitBinaryOperator(const BinaryOperator *BO);
163
164    void VisitObjCMessageExpr(const ObjCMessageExpr *ME);
165
166    void VisitChildren(const Stmt *S) {
167      for (Stmt::const_child_range I = S->children(); I; ++I) {
168        if (*I)
169          this->Visit(*I);
170        if (CalledAnotherInvalidationMethod)
171          return;
172      }
173    }
174  };
175
176  /// Check if the any of the methods inside the interface are annotated with
177  /// the invalidation annotation, update the IvarInfo accordingly.
178  /// \param LookForPartial is set when we are searching for partial
179  ///        invalidators.
180  static void containsInvalidationMethod(const ObjCContainerDecl *D,
181                                         InvalidationInfo &Out,
182                                         bool LookForPartial);
183
184  /// Check if ivar should be tracked and add to TrackedIvars if positive.
185  /// Returns true if ivar should be tracked.
186  static bool trackIvar(const ObjCIvarDecl *Iv, IvarSet &TrackedIvars,
187                        const ObjCIvarDecl **FirstIvarDecl);
188
189  /// Given the property declaration, and the list of tracked ivars, finds
190  /// the ivar backing the property when possible. Returns '0' when no such
191  /// ivar could be found.
192  static const ObjCIvarDecl *findPropertyBackingIvar(
193      const ObjCPropertyDecl *Prop,
194      const ObjCInterfaceDecl *InterfaceD,
195      IvarSet &TrackedIvars,
196      const ObjCIvarDecl **FirstIvarDecl);
197
198  /// Print ivar name or the property if the given ivar backs a property.
199  static void printIvar(llvm::raw_svector_ostream &os,
200                        const ObjCIvarDecl *IvarDecl,
201                        const IvarToPropMapTy &IvarToPopertyMap);
202
203  void reportNoInvalidationMethod(const ObjCIvarDecl *FirstIvarDecl,
204                                  const IvarToPropMapTy &IvarToPopertyMap,
205                                  const ObjCInterfaceDecl *InterfaceD,
206                                  bool MissingDeclaration) const;
207  void reportIvarNeedsInvalidation(const ObjCIvarDecl *IvarD,
208                                   const IvarToPropMapTy &IvarToPopertyMap,
209                                   const ObjCMethodDecl *MethodD) const;
210
211  AnalysisManager& Mgr;
212  BugReporter &BR;
213  /// Filter on the checks performed.
214  const ChecksFilter &Filter;
215
216public:
217  IvarInvalidationCheckerImpl(AnalysisManager& InMgr,
218                              BugReporter &InBR,
219                              const ChecksFilter &InFilter) :
220    Mgr (InMgr), BR(InBR), Filter(InFilter) {}
221
222  void visit(const ObjCImplementationDecl *D) const;
223};
224
225static bool isInvalidationMethod(const ObjCMethodDecl *M, bool LookForPartial) {
226  for (specific_attr_iterator<AnnotateAttr>
227       AI = M->specific_attr_begin<AnnotateAttr>(),
228       AE = M->specific_attr_end<AnnotateAttr>(); AI != AE; ++AI) {
229    const AnnotateAttr *Ann = *AI;
230    if (!LookForPartial &&
231        Ann->getAnnotation() == "objc_instance_variable_invalidator")
232      return true;
233    if (LookForPartial &&
234        Ann->getAnnotation() == "objc_instance_variable_invalidator_partial")
235      return true;
236  }
237  return false;
238}
239
240void IvarInvalidationCheckerImpl::containsInvalidationMethod(
241    const ObjCContainerDecl *D, InvalidationInfo &OutInfo, bool Partial) {
242
243  if (!D)
244    return;
245
246  assert(!isa<ObjCImplementationDecl>(D));
247  // TODO: Cache the results.
248
249  // Check all methods.
250  for (ObjCContainerDecl::method_iterator
251      I = D->meth_begin(),
252      E = D->meth_end(); I != E; ++I) {
253      const ObjCMethodDecl *MDI = *I;
254      if (isInvalidationMethod(MDI, Partial))
255        OutInfo.addInvalidationMethod(
256                               cast<ObjCMethodDecl>(MDI->getCanonicalDecl()));
257  }
258
259  // If interface, check all parent protocols and super.
260  if (const ObjCInterfaceDecl *InterfD = dyn_cast<ObjCInterfaceDecl>(D)) {
261
262    // Visit all protocols.
263    for (ObjCInterfaceDecl::protocol_iterator
264        I = InterfD->protocol_begin(),
265        E = InterfD->protocol_end(); I != E; ++I) {
266      containsInvalidationMethod((*I)->getDefinition(), OutInfo, Partial);
267    }
268
269    // Visit all categories in case the invalidation method is declared in
270    // a category.
271    for (ObjCInterfaceDecl::visible_extensions_iterator
272           Ext = InterfD->visible_extensions_begin(),
273           ExtEnd = InterfD->visible_extensions_end();
274         Ext != ExtEnd; ++Ext) {
275      containsInvalidationMethod(*Ext, OutInfo, Partial);
276    }
277
278    containsInvalidationMethod(InterfD->getSuperClass(), OutInfo, Partial);
279    return;
280  }
281
282  // If protocol, check all parent protocols.
283  if (const ObjCProtocolDecl *ProtD = dyn_cast<ObjCProtocolDecl>(D)) {
284    for (ObjCInterfaceDecl::protocol_iterator
285        I = ProtD->protocol_begin(),
286        E = ProtD->protocol_end(); I != E; ++I) {
287      containsInvalidationMethod((*I)->getDefinition(), OutInfo, Partial);
288    }
289    return;
290  }
291
292  return;
293}
294
295bool IvarInvalidationCheckerImpl::trackIvar(const ObjCIvarDecl *Iv,
296                                        IvarSet &TrackedIvars,
297                                        const ObjCIvarDecl **FirstIvarDecl) {
298  QualType IvQTy = Iv->getType();
299  const ObjCObjectPointerType *IvTy = IvQTy->getAs<ObjCObjectPointerType>();
300  if (!IvTy)
301    return false;
302  const ObjCInterfaceDecl *IvInterf = IvTy->getInterfaceDecl();
303
304  InvalidationInfo Info;
305  containsInvalidationMethod(IvInterf, Info, /*LookForPartial*/ false);
306  if (Info.needsInvalidation()) {
307    const ObjCIvarDecl *I = cast<ObjCIvarDecl>(Iv->getCanonicalDecl());
308    TrackedIvars[I] = Info;
309    if (!*FirstIvarDecl)
310      *FirstIvarDecl = I;
311    return true;
312  }
313  return false;
314}
315
316const ObjCIvarDecl *IvarInvalidationCheckerImpl::findPropertyBackingIvar(
317                        const ObjCPropertyDecl *Prop,
318                        const ObjCInterfaceDecl *InterfaceD,
319                        IvarSet &TrackedIvars,
320                        const ObjCIvarDecl **FirstIvarDecl) {
321  const ObjCIvarDecl *IvarD = 0;
322
323  // Lookup for the synthesized case.
324  IvarD = Prop->getPropertyIvarDecl();
325  // We only track the ivars/properties that are defined in the current
326  // class (not the parent).
327  if (IvarD && IvarD->getContainingInterface() == InterfaceD) {
328    if (TrackedIvars.count(IvarD)) {
329      return IvarD;
330    }
331    // If the ivar is synthesized we still want to track it.
332    if (trackIvar(IvarD, TrackedIvars, FirstIvarDecl))
333      return IvarD;
334  }
335
336  // Lookup IVars named "_PropName"or "PropName" among the tracked Ivars.
337  StringRef PropName = Prop->getIdentifier()->getName();
338  for (IvarSet::const_iterator I = TrackedIvars.begin(),
339                               E = TrackedIvars.end(); I != E; ++I) {
340    const ObjCIvarDecl *Iv = I->first;
341    StringRef IvarName = Iv->getName();
342
343    if (IvarName == PropName)
344      return Iv;
345
346    SmallString<128> PropNameWithUnderscore;
347    {
348      llvm::raw_svector_ostream os(PropNameWithUnderscore);
349      os << '_' << PropName;
350    }
351    if (IvarName == PropNameWithUnderscore.str())
352      return Iv;
353  }
354
355  // Note, this is a possible source of false positives. We could look at the
356  // getter implementation to find the ivar when its name is not derived from
357  // the property name.
358  return 0;
359}
360
361void IvarInvalidationCheckerImpl::printIvar(llvm::raw_svector_ostream &os,
362                                      const ObjCIvarDecl *IvarDecl,
363                                      const IvarToPropMapTy &IvarToPopertyMap) {
364  if (IvarDecl->getSynthesize()) {
365    const ObjCPropertyDecl *PD = IvarToPopertyMap.lookup(IvarDecl);
366    assert(PD &&"Do we synthesize ivars for something other than properties?");
367    os << "Property "<< PD->getName() << " ";
368  } else {
369    os << "Instance variable "<< IvarDecl->getName() << " ";
370  }
371}
372
373// Check that the invalidatable interfaces with ivars/properties implement the
374// invalidation methods.
375void IvarInvalidationCheckerImpl::
376visit(const ObjCImplementationDecl *ImplD) const {
377  // Collect all ivars that need cleanup.
378  IvarSet Ivars;
379  // Record the first Ivar needing invalidation; used in reporting when only
380  // one ivar is sufficient. Cannot grab the first on the Ivars set to ensure
381  // deterministic output.
382  const ObjCIvarDecl *FirstIvarDecl = 0;
383  const ObjCInterfaceDecl *InterfaceD = ImplD->getClassInterface();
384
385  // Collect ivars declared in this class, its extensions and its implementation
386  ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(InterfaceD);
387  for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
388       Iv= Iv->getNextIvar())
389    trackIvar(Iv, Ivars, &FirstIvarDecl);
390
391  // Construct Property/Property Accessor to Ivar maps to assist checking if an
392  // ivar which is backing a property has been reset.
393  MethToIvarMapTy PropSetterToIvarMap;
394  MethToIvarMapTy PropGetterToIvarMap;
395  PropToIvarMapTy PropertyToIvarMap;
396  IvarToPropMapTy IvarToPopertyMap;
397
398  ObjCInterfaceDecl::PropertyMap PropMap;
399  InterfaceD->collectPropertiesToImplement(PropMap);
400
401  for (ObjCInterfaceDecl::PropertyMap::iterator
402      I = PropMap.begin(), E = PropMap.end(); I != E; ++I) {
403    const ObjCPropertyDecl *PD = I->second;
404
405    const ObjCIvarDecl *ID = findPropertyBackingIvar(PD, InterfaceD, Ivars,
406                                                     &FirstIvarDecl);
407    if (!ID)
408      continue;
409
410    // Store the mappings.
411    PD = cast<ObjCPropertyDecl>(PD->getCanonicalDecl());
412    PropertyToIvarMap[PD] = ID;
413    IvarToPopertyMap[ID] = PD;
414
415    // Find the setter and the getter.
416    const ObjCMethodDecl *SetterD = PD->getSetterMethodDecl();
417    if (SetterD) {
418      SetterD = cast<ObjCMethodDecl>(SetterD->getCanonicalDecl());
419      PropSetterToIvarMap[SetterD] = ID;
420    }
421
422    const ObjCMethodDecl *GetterD = PD->getGetterMethodDecl();
423    if (GetterD) {
424      GetterD = cast<ObjCMethodDecl>(GetterD->getCanonicalDecl());
425      PropGetterToIvarMap[GetterD] = ID;
426    }
427  }
428
429  // If no ivars need invalidation, there is nothing to check here.
430  if (Ivars.empty())
431    return;
432
433  // Find all partial invalidation methods.
434  InvalidationInfo PartialInfo;
435  containsInvalidationMethod(InterfaceD, PartialInfo, /*LookForPartial*/ true);
436
437  // Remove ivars invalidated by the partial invalidation methods. They do not
438  // need to be invalidated in the regular invalidation methods.
439  for (MethodSet::iterator
440      I = PartialInfo.InvalidationMethods.begin(),
441      E = PartialInfo.InvalidationMethods.end(); I != E; ++I) {
442    const ObjCMethodDecl *InterfD = *I;
443
444    // Get the corresponding method in the @implementation.
445    const ObjCMethodDecl *D = ImplD->getMethod(InterfD->getSelector(),
446                                               InterfD->isInstanceMethod());
447    if (D && D->hasBody()) {
448      bool CalledAnotherInvalidationMethod = false;
449      // The MethodCrowler is going to remove the invalidated ivars.
450      MethodCrawler(Ivars,
451                    CalledAnotherInvalidationMethod,
452                    PropSetterToIvarMap,
453                    PropGetterToIvarMap,
454                    PropertyToIvarMap,
455                    BR.getContext()).VisitStmt(D->getBody());
456      // If another invalidation method was called, trust that full invalidation
457      // has occurred.
458      if (CalledAnotherInvalidationMethod)
459        Ivars.clear();
460    }
461  }
462
463  // If all ivars have been invalidated by partial invalidators, there is
464  // nothing to check here.
465  if (Ivars.empty())
466    return;
467
468  // Find all invalidation methods in this @interface declaration and parents.
469  InvalidationInfo Info;
470  containsInvalidationMethod(InterfaceD, Info, /*LookForPartial*/ false);
471
472  // Report an error in case none of the invalidation methods are declared.
473  if (!Info.needsInvalidation()) {
474    if (Filter.check_MissingInvalidationMethod)
475      reportNoInvalidationMethod(FirstIvarDecl, IvarToPopertyMap, InterfaceD,
476                                 /*MissingDeclaration*/ true);
477    // If there are no invalidation methods, there is no ivar validation work
478    // to be done.
479    return;
480  }
481
482  // Only check if Ivars are invalidated when InstanceVariableInvalidation
483  // has been requested.
484  if (!Filter.check_InstanceVariableInvalidation)
485    return;
486
487  // Check that all ivars are invalidated by the invalidation methods.
488  bool AtImplementationContainsAtLeastOneInvalidationMethod = false;
489  for (MethodSet::iterator I = Info.InvalidationMethods.begin(),
490                           E = Info.InvalidationMethods.end(); I != E; ++I) {
491    const ObjCMethodDecl *InterfD = *I;
492
493    // Get the corresponding method in the @implementation.
494    const ObjCMethodDecl *D = ImplD->getMethod(InterfD->getSelector(),
495                                               InterfD->isInstanceMethod());
496    if (D && D->hasBody()) {
497      AtImplementationContainsAtLeastOneInvalidationMethod = true;
498
499      // Get a copy of ivars needing invalidation.
500      IvarSet IvarsI = Ivars;
501
502      bool CalledAnotherInvalidationMethod = false;
503      MethodCrawler(IvarsI,
504                    CalledAnotherInvalidationMethod,
505                    PropSetterToIvarMap,
506                    PropGetterToIvarMap,
507                    PropertyToIvarMap,
508                    BR.getContext()).VisitStmt(D->getBody());
509      // If another invalidation method was called, trust that full invalidation
510      // has occurred.
511      if (CalledAnotherInvalidationMethod)
512        continue;
513
514      // Warn on the ivars that were not invalidated by the method.
515      for (IvarSet::const_iterator
516          I = IvarsI.begin(), E = IvarsI.end(); I != E; ++I)
517        reportIvarNeedsInvalidation(I->first, IvarToPopertyMap, D);
518    }
519  }
520
521  // Report an error in case none of the invalidation methods are implemented.
522  if (!AtImplementationContainsAtLeastOneInvalidationMethod)
523    reportNoInvalidationMethod(FirstIvarDecl, IvarToPopertyMap, InterfaceD,
524                               /*MissingDeclaration*/ false);
525}
526
527void IvarInvalidationCheckerImpl::
528reportNoInvalidationMethod(const ObjCIvarDecl *FirstIvarDecl,
529                           const IvarToPropMapTy &IvarToPopertyMap,
530                           const ObjCInterfaceDecl *InterfaceD,
531                           bool MissingDeclaration) const {
532  SmallString<128> sbuf;
533  llvm::raw_svector_ostream os(sbuf);
534  assert(FirstIvarDecl);
535  printIvar(os, FirstIvarDecl, IvarToPopertyMap);
536  os << "needs to be invalidated; ";
537  if (MissingDeclaration)
538    os << "no invalidation method is declared for ";
539  else
540    os << "no invalidation method is defined in the @implementation for ";
541  os << InterfaceD->getName();
542
543  PathDiagnosticLocation IvarDecLocation =
544    PathDiagnosticLocation::createBegin(FirstIvarDecl, BR.getSourceManager());
545
546  BR.EmitBasicReport(FirstIvarDecl, "Incomplete invalidation",
547                     categories::CoreFoundationObjectiveC, os.str(),
548                     IvarDecLocation);
549}
550
551void IvarInvalidationCheckerImpl::
552reportIvarNeedsInvalidation(const ObjCIvarDecl *IvarD,
553                                    const IvarToPropMapTy &IvarToPopertyMap,
554                                    const ObjCMethodDecl *MethodD) const {
555  SmallString<128> sbuf;
556  llvm::raw_svector_ostream os(sbuf);
557  printIvar(os, IvarD, IvarToPopertyMap);
558  os << "needs to be invalidated or set to nil";
559  PathDiagnosticLocation MethodDecLocation =
560                         PathDiagnosticLocation::createEnd(MethodD->getBody(),
561                         BR.getSourceManager(),
562                         Mgr.getAnalysisDeclContext(MethodD));
563  BR.EmitBasicReport(MethodD, "Incomplete invalidation",
564                     categories::CoreFoundationObjectiveC, os.str(),
565                     MethodDecLocation);
566}
567
568void IvarInvalidationCheckerImpl::MethodCrawler::markInvalidated(
569    const ObjCIvarDecl *Iv) {
570  IvarSet::iterator I = IVars.find(Iv);
571  if (I != IVars.end()) {
572    // If InvalidationMethod is present, we are processing the message send and
573    // should ensure we are invalidating with the appropriate method,
574    // otherwise, we are processing setting to 'nil'.
575    if (!InvalidationMethod ||
576        (InvalidationMethod && I->second.hasMethod(InvalidationMethod)))
577      IVars.erase(I);
578  }
579}
580
581const Expr *IvarInvalidationCheckerImpl::MethodCrawler::peel(const Expr *E) const {
582  E = E->IgnoreParenCasts();
583  if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
584    E = POE->getSyntacticForm()->IgnoreParenCasts();
585  if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
586    E = OVE->getSourceExpr()->IgnoreParenCasts();
587  return E;
588}
589
590void IvarInvalidationCheckerImpl::MethodCrawler::checkObjCIvarRefExpr(
591    const ObjCIvarRefExpr *IvarRef) {
592  if (const Decl *D = IvarRef->getDecl())
593    markInvalidated(cast<ObjCIvarDecl>(D->getCanonicalDecl()));
594}
595
596void IvarInvalidationCheckerImpl::MethodCrawler::checkObjCMessageExpr(
597    const ObjCMessageExpr *ME) {
598  const ObjCMethodDecl *MD = ME->getMethodDecl();
599  if (MD) {
600    MD = cast<ObjCMethodDecl>(MD->getCanonicalDecl());
601    MethToIvarMapTy::const_iterator IvI = PropertyGetterToIvarMap.find(MD);
602    if (IvI != PropertyGetterToIvarMap.end())
603      markInvalidated(IvI->second);
604  }
605}
606
607void IvarInvalidationCheckerImpl::MethodCrawler::checkObjCPropertyRefExpr(
608    const ObjCPropertyRefExpr *PA) {
609
610  if (PA->isExplicitProperty()) {
611    const ObjCPropertyDecl *PD = PA->getExplicitProperty();
612    if (PD) {
613      PD = cast<ObjCPropertyDecl>(PD->getCanonicalDecl());
614      PropToIvarMapTy::const_iterator IvI = PropertyToIvarMap.find(PD);
615      if (IvI != PropertyToIvarMap.end())
616        markInvalidated(IvI->second);
617      return;
618    }
619  }
620
621  if (PA->isImplicitProperty()) {
622    const ObjCMethodDecl *MD = PA->getImplicitPropertySetter();
623    if (MD) {
624      MD = cast<ObjCMethodDecl>(MD->getCanonicalDecl());
625      MethToIvarMapTy::const_iterator IvI =PropertyGetterToIvarMap.find(MD);
626      if (IvI != PropertyGetterToIvarMap.end())
627        markInvalidated(IvI->second);
628      return;
629    }
630  }
631}
632
633bool IvarInvalidationCheckerImpl::MethodCrawler::isZero(const Expr *E) const {
634  E = peel(E);
635
636  return (E->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNotNull)
637           != Expr::NPCK_NotNull);
638}
639
640void IvarInvalidationCheckerImpl::MethodCrawler::check(const Expr *E) {
641  E = peel(E);
642
643  if (const ObjCIvarRefExpr *IvarRef = dyn_cast<ObjCIvarRefExpr>(E)) {
644    checkObjCIvarRefExpr(IvarRef);
645    return;
646  }
647
648  if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E)) {
649    checkObjCPropertyRefExpr(PropRef);
650    return;
651  }
652
653  if (const ObjCMessageExpr *MsgExpr = dyn_cast<ObjCMessageExpr>(E)) {
654    checkObjCMessageExpr(MsgExpr);
655    return;
656  }
657}
658
659void IvarInvalidationCheckerImpl::MethodCrawler::VisitBinaryOperator(
660    const BinaryOperator *BO) {
661  VisitStmt(BO);
662
663  // Do we assign/compare against zero? If yes, check the variable we are
664  // assigning to.
665  BinaryOperatorKind Opcode = BO->getOpcode();
666  if (Opcode != BO_Assign &&
667      Opcode != BO_EQ &&
668      Opcode != BO_NE)
669    return;
670
671  if (isZero(BO->getRHS())) {
672      check(BO->getLHS());
673      return;
674  }
675
676  if (Opcode != BO_Assign && isZero(BO->getLHS())) {
677    check(BO->getRHS());
678    return;
679  }
680}
681
682void IvarInvalidationCheckerImpl::MethodCrawler::VisitObjCMessageExpr(
683  const ObjCMessageExpr *ME) {
684  const ObjCMethodDecl *MD = ME->getMethodDecl();
685  const Expr *Receiver = ME->getInstanceReceiver();
686
687  // Stop if we are calling '[self invalidate]'.
688  if (Receiver && isInvalidationMethod(MD, /*LookForPartial*/ false))
689    if (Receiver->isObjCSelfExpr()) {
690      CalledAnotherInvalidationMethod = true;
691      return;
692    }
693
694  // Check if we call a setter and set the property to 'nil'.
695  if (MD && (ME->getNumArgs() == 1) && isZero(ME->getArg(0))) {
696    MD = cast<ObjCMethodDecl>(MD->getCanonicalDecl());
697    MethToIvarMapTy::const_iterator IvI = PropertySetterToIvarMap.find(MD);
698    if (IvI != PropertySetterToIvarMap.end()) {
699      markInvalidated(IvI->second);
700      return;
701    }
702  }
703
704  // Check if we call the 'invalidation' routine on the ivar.
705  if (Receiver) {
706    InvalidationMethod = MD;
707    check(Receiver->IgnoreParenCasts());
708    InvalidationMethod = 0;
709  }
710
711  VisitStmt(ME);
712}
713}
714
715// Register the checkers.
716namespace {
717
718class IvarInvalidationChecker :
719  public Checker<check::ASTDecl<ObjCImplementationDecl> > {
720public:
721  ChecksFilter Filter;
722public:
723  void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& Mgr,
724                    BugReporter &BR) const {
725    IvarInvalidationCheckerImpl Walker(Mgr, BR, Filter);
726    Walker.visit(D);
727  }
728};
729}
730
731#define REGISTER_CHECKER(name) \
732void ento::register##name(CheckerManager &mgr) {\
733  mgr.registerChecker<IvarInvalidationChecker>()->Filter.check_##name = true;\
734}
735
736REGISTER_CHECKER(InstanceVariableInvalidation)
737REGISTER_CHECKER(MissingInvalidationMethod)
738
739