IvarInvalidationChecker.cpp source code [clang_source_code/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp]

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

Clang Project