1 //===- ObjCSuperDeallocChecker.cpp - Check correct use of [super dealloc] -===//
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 ObjCSuperDeallocChecker, a builtin check that warns when
11 // self is used after a call to [super dealloc] in MRR mode.
13 //===----------------------------------------------------------------------===//
15 #include "ClangSACheckers.h"
16 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
17 #include "clang/StaticAnalyzer/Core/Checker.h"
18 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
19 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
20 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
21 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
23 using namespace clang;
27 class ObjCSuperDeallocChecker
28 : public Checker<check::PostObjCMessage, check::PreObjCMessage,
29 check::PreCall, check::Location> {
31 mutable IdentifierInfo *IIdealloc, *IINSObject;
32 mutable Selector SELdealloc;
34 std::unique_ptr<BugType> DoubleSuperDeallocBugType;
36 void initIdentifierInfoAndSelectors(ASTContext &Ctx) const;
38 bool isSuperDeallocMessage(const ObjCMethodCall &M) const;
41 ObjCSuperDeallocChecker();
42 void checkPostObjCMessage(const ObjCMethodCall &M, CheckerContext &C) const;
43 void checkPreObjCMessage(const ObjCMethodCall &M, CheckerContext &C) const;
45 void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
47 void checkLocation(SVal l, bool isLoad, const Stmt *S,
48 CheckerContext &C) const;
52 void diagnoseCallArguments(const CallEvent &CE, CheckerContext &C) const;
54 void reportUseAfterDealloc(SymbolRef Sym, StringRef Desc, const Stmt *S,
55 CheckerContext &C) const;
58 } // End anonymous namespace.
60 // Remember whether [super dealloc] has previously been called on the
61 // SymbolRef for the receiver.
62 REGISTER_SET_WITH_PROGRAMSTATE(CalledSuperDealloc, SymbolRef)
65 class SuperDeallocBRVisitor final
66 : public BugReporterVisitorImpl<SuperDeallocBRVisitor> {
68 SymbolRef ReceiverSymbol;
72 SuperDeallocBRVisitor(SymbolRef ReceiverSymbol)
73 : ReceiverSymbol(ReceiverSymbol),
76 std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *Succ,
77 const ExplodedNode *Pred,
78 BugReporterContext &BRC,
79 BugReport &BR) override;
81 void Profile(llvm::FoldingSetNodeID &ID) const override {
82 ID.Add(ReceiverSymbol);
85 } // End anonymous namespace.
87 void ObjCSuperDeallocChecker::checkPreObjCMessage(const ObjCMethodCall &M,
88 CheckerContext &C) const {
90 ProgramStateRef State = C.getState();
91 SymbolRef ReceiverSymbol = M.getReceiverSVal().getAsSymbol();
92 if (!ReceiverSymbol) {
93 diagnoseCallArguments(M, C);
97 bool AlreadyCalled = State->contains<CalledSuperDealloc>(ReceiverSymbol);
103 if (isSuperDeallocMessage(M)) {
104 Desc = "[super dealloc] should not be called multiple times";
109 reportUseAfterDealloc(ReceiverSymbol, Desc, M.getOriginExpr(), C);
112 void ObjCSuperDeallocChecker::checkPreCall(const CallEvent &Call,
113 CheckerContext &C) const {
114 diagnoseCallArguments(Call, C);
117 void ObjCSuperDeallocChecker::checkPostObjCMessage(const ObjCMethodCall &M,
118 CheckerContext &C) const {
119 // Check for [super dealloc] method call.
120 if (!isSuperDeallocMessage(M))
123 ProgramStateRef State = C.getState();
124 SymbolRef ReceiverSymbol = M.getSelfSVal().getAsSymbol();
125 assert(ReceiverSymbol && "No receiver symbol at call to [super dealloc]?");
127 // We add this transition in checkPostObjCMessage to avoid warning when
128 // we inline a call to [super dealloc] where the inlined call itself
129 // calls [super dealloc].
130 State = State->add<CalledSuperDealloc>(ReceiverSymbol);
131 C.addTransition(State);
134 void ObjCSuperDeallocChecker::checkLocation(SVal L, bool IsLoad, const Stmt *S,
135 CheckerContext &C) const {
136 SymbolRef BaseSym = L.getLocSymbolInBase();
140 ProgramStateRef State = C.getState();
142 if (!State->contains<CalledSuperDealloc>(BaseSym))
145 const MemRegion *R = L.getAsRegion();
149 // Climb the super regions to find the base symbol while recording
150 // the second-to-last region for error reporting.
151 const MemRegion *PriorSubRegion = nullptr;
152 while (const SubRegion *SR = dyn_cast<SubRegion>(R)) {
153 if (const SymbolicRegion *SymR = dyn_cast<SymbolicRegion>(SR)) {
154 BaseSym = SymR->getSymbol();
157 R = SR->getSuperRegion();
162 StringRef Desc = StringRef();
163 auto *IvarRegion = dyn_cast_or_null<ObjCIvarRegion>(PriorSubRegion);
166 llvm::raw_string_ostream OS(Buf);
168 OS << "Use of instance variable '" << *IvarRegion->getDecl() <<
169 "' after 'self' has been deallocated";
173 reportUseAfterDealloc(BaseSym, Desc, S, C);
176 /// Report a use-after-dealloc on Sym. If not empty,
177 /// Desc will be used to describe the error; otherwise,
178 /// a default warning will be used.
179 void ObjCSuperDeallocChecker::reportUseAfterDealloc(SymbolRef Sym,
182 CheckerContext &C) const {
183 // We have a use of self after free.
184 // This likely causes a crash, so stop exploring the
185 // path by generating a sink.
186 ExplodedNode *ErrNode = C.generateErrorNode();
187 // If we've already reached this node on another path, return.
192 Desc = "Use of 'self' after it has been deallocated";
194 // Generate the report.
195 std::unique_ptr<BugReport> BR(
196 new BugReport(*DoubleSuperDeallocBugType, Desc, ErrNode));
197 BR->addRange(S->getSourceRange());
198 BR->addVisitor(llvm::make_unique<SuperDeallocBRVisitor>(Sym));
199 C.emitReport(std::move(BR));
202 /// Diagnose if any of the arguments to CE have already been
204 void ObjCSuperDeallocChecker::diagnoseCallArguments(const CallEvent &CE,
205 CheckerContext &C) const {
206 ProgramStateRef State = C.getState();
207 unsigned ArgCount = CE.getNumArgs();
208 for (unsigned I = 0; I < ArgCount; I++) {
209 SymbolRef Sym = CE.getArgSVal(I).getAsSymbol();
213 if (State->contains<CalledSuperDealloc>(Sym)) {
214 reportUseAfterDealloc(Sym, StringRef(), CE.getArgExpr(I), C);
220 ObjCSuperDeallocChecker::ObjCSuperDeallocChecker()
221 : IIdealloc(nullptr), IINSObject(nullptr) {
223 DoubleSuperDeallocBugType.reset(
224 new BugType(this, "[super dealloc] should not be called more than once",
225 categories::CoreFoundationObjectiveC));
229 ObjCSuperDeallocChecker::initIdentifierInfoAndSelectors(ASTContext &Ctx) const {
233 IIdealloc = &Ctx.Idents.get("dealloc");
234 IINSObject = &Ctx.Idents.get("NSObject");
236 SELdealloc = Ctx.Selectors.getSelector(0, &IIdealloc);
240 ObjCSuperDeallocChecker::isSuperDeallocMessage(const ObjCMethodCall &M) const {
241 if (M.getOriginExpr()->getReceiverKind() != ObjCMessageExpr::SuperInstance)
244 ASTContext &Ctx = M.getState()->getStateManager().getContext();
245 initIdentifierInfoAndSelectors(Ctx);
247 return M.getSelector() == SELdealloc;
250 std::shared_ptr<PathDiagnosticPiece>
251 SuperDeallocBRVisitor::VisitNode(const ExplodedNode *Succ,
252 const ExplodedNode *Pred,
253 BugReporterContext &BRC, BugReport &BR) {
257 ProgramStateRef State = Succ->getState();
260 Succ->getState()->contains<CalledSuperDealloc>(ReceiverSymbol);
262 Pred->getState()->contains<CalledSuperDealloc>(ReceiverSymbol);
264 // Is Succ the node on which the analyzer noted that [super dealloc] was
265 // called on ReceiverSymbol?
266 if (CalledNow && !CalledBefore) {
269 ProgramPoint P = Succ->getLocation();
270 PathDiagnosticLocation L =
271 PathDiagnosticLocation::create(P, BRC.getSourceManager());
273 if (!L.isValid() || !L.asLocation().isValid())
276 return std::make_shared<PathDiagnosticEventPiece>(
277 L, "[super dealloc] called here");
283 //===----------------------------------------------------------------------===//
284 // Checker Registration.
285 //===----------------------------------------------------------------------===//
287 void ento::registerObjCSuperDeallocChecker(CheckerManager &Mgr) {
288 const LangOptions &LangOpts = Mgr.getLangOpts();
289 if (LangOpts.getGC() == LangOptions::GCOnly || LangOpts.ObjCAutoRefCount)
291 Mgr.registerChecker<ObjCSuperDeallocChecker>();