clang  6.0.0svn
ObjCSuperDeallocChecker.cpp
Go to the documentation of this file.
1 //===- ObjCSuperDeallocChecker.cpp - Check correct use of [super dealloc] -===//
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 defines ObjCSuperDeallocChecker, a builtin check that warns when
11 // self is used after a call to [super dealloc] in MRR mode.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "ClangSACheckers.h"
22 
23 using namespace clang;
24 using namespace ento;
25 
26 namespace {
27 class ObjCSuperDeallocChecker
28  : public Checker<check::PostObjCMessage, check::PreObjCMessage,
29  check::PreCall, check::Location> {
30 
31  mutable IdentifierInfo *IIdealloc, *IINSObject;
32  mutable Selector SELdealloc;
33 
34  std::unique_ptr<BugType> DoubleSuperDeallocBugType;
35 
36  void initIdentifierInfoAndSelectors(ASTContext &Ctx) const;
37 
38  bool isSuperDeallocMessage(const ObjCMethodCall &M) const;
39 
40 public:
41  ObjCSuperDeallocChecker();
42  void checkPostObjCMessage(const ObjCMethodCall &M, CheckerContext &C) const;
43  void checkPreObjCMessage(const ObjCMethodCall &M, CheckerContext &C) const;
44 
45  void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
46 
47  void checkLocation(SVal l, bool isLoad, const Stmt *S,
48  CheckerContext &C) const;
49 
50 private:
51 
52  void diagnoseCallArguments(const CallEvent &CE, CheckerContext &C) const;
53 
54  void reportUseAfterDealloc(SymbolRef Sym, StringRef Desc, const Stmt *S,
55  CheckerContext &C) const;
56 };
57 
58 } // End anonymous namespace.
59 
60 // Remember whether [super dealloc] has previously been called on the
61 // SymbolRef for the receiver.
62 REGISTER_SET_WITH_PROGRAMSTATE(CalledSuperDealloc, SymbolRef)
63 
64 namespace {
65 class SuperDeallocBRVisitor final
66  : public BugReporterVisitorImpl<SuperDeallocBRVisitor> {
67 
68  SymbolRef ReceiverSymbol;
69  bool Satisfied;
70 
71 public:
72  SuperDeallocBRVisitor(SymbolRef ReceiverSymbol)
73  : ReceiverSymbol(ReceiverSymbol),
74  Satisfied(false) {}
75 
76  std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *Succ,
77  const ExplodedNode *Pred,
78  BugReporterContext &BRC,
79  BugReport &BR) override;
80 
81  void Profile(llvm::FoldingSetNodeID &ID) const override {
82  ID.Add(ReceiverSymbol);
83  }
84 };
85 } // End anonymous namespace.
86 
87 void ObjCSuperDeallocChecker::checkPreObjCMessage(const ObjCMethodCall &M,
88  CheckerContext &C) const {
89 
91  SymbolRef ReceiverSymbol = M.getReceiverSVal().getAsSymbol();
92  if (!ReceiverSymbol) {
93  diagnoseCallArguments(M, C);
94  return;
95  }
96 
97  bool AlreadyCalled = State->contains<CalledSuperDealloc>(ReceiverSymbol);
98  if (!AlreadyCalled)
99  return;
100 
101  StringRef Desc;
102 
103  if (isSuperDeallocMessage(M)) {
104  Desc = "[super dealloc] should not be called multiple times";
105  } else {
106  Desc = StringRef();
107  }
108 
109  reportUseAfterDealloc(ReceiverSymbol, Desc, M.getOriginExpr(), C);
110 }
111 
112 void ObjCSuperDeallocChecker::checkPreCall(const CallEvent &Call,
113  CheckerContext &C) const {
114  diagnoseCallArguments(Call, C);
115 }
116 
117 void ObjCSuperDeallocChecker::checkPostObjCMessage(const ObjCMethodCall &M,
118  CheckerContext &C) const {
119  // Check for [super dealloc] method call.
120  if (!isSuperDeallocMessage(M))
121  return;
122 
123  ProgramStateRef State = C.getState();
124  SymbolRef ReceiverSymbol = M.getSelfSVal().getAsSymbol();
125  assert(ReceiverSymbol && "No receiver symbol at call to [super dealloc]?");
126 
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);
132 }
133 
134 void ObjCSuperDeallocChecker::checkLocation(SVal L, bool IsLoad, const Stmt *S,
135  CheckerContext &C) const {
136  SymbolRef BaseSym = L.getLocSymbolInBase();
137  if (!BaseSym)
138  return;
139 
140  ProgramStateRef State = C.getState();
141 
142  if (!State->contains<CalledSuperDealloc>(BaseSym))
143  return;
144 
145  const MemRegion *R = L.getAsRegion();
146  if (!R)
147  return;
148 
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();
155  break;
156  } else {
157  R = SR->getSuperRegion();
158  PriorSubRegion = SR;
159  }
160  }
161 
162  StringRef Desc = StringRef();
163  auto *IvarRegion = dyn_cast_or_null<ObjCIvarRegion>(PriorSubRegion);
164 
165  std::string Buf;
166  llvm::raw_string_ostream OS(Buf);
167  if (IvarRegion) {
168  OS << "Use of instance variable '" << *IvarRegion->getDecl() <<
169  "' after 'self' has been deallocated";
170  Desc = OS.str();
171  }
172 
173  reportUseAfterDealloc(BaseSym, Desc, S, C);
174 }
175 
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,
180  StringRef Desc,
181  const Stmt *S,
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.
188  if (!ErrNode)
189  return;
190 
191  if (Desc.empty())
192  Desc = "Use of 'self' after it has been deallocated";
193 
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));
200 }
201 
202 /// Diagnose if any of the arguments to CE have already been
203 /// dealloc'd.
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();
210  if (!Sym)
211  continue;
212 
213  if (State->contains<CalledSuperDealloc>(Sym)) {
214  reportUseAfterDealloc(Sym, StringRef(), CE.getArgExpr(I), C);
215  return;
216  }
217  }
218 }
219 
220 ObjCSuperDeallocChecker::ObjCSuperDeallocChecker()
221  : IIdealloc(nullptr), IINSObject(nullptr) {
222 
223  DoubleSuperDeallocBugType.reset(
224  new BugType(this, "[super dealloc] should not be called more than once",
226 }
227 
228 void
229 ObjCSuperDeallocChecker::initIdentifierInfoAndSelectors(ASTContext &Ctx) const {
230  if (IIdealloc)
231  return;
232 
233  IIdealloc = &Ctx.Idents.get("dealloc");
234  IINSObject = &Ctx.Idents.get("NSObject");
235 
236  SELdealloc = Ctx.Selectors.getSelector(0, &IIdealloc);
237 }
238 
239 bool
240 ObjCSuperDeallocChecker::isSuperDeallocMessage(const ObjCMethodCall &M) const {
241  if (M.getOriginExpr()->getReceiverKind() != ObjCMessageExpr::SuperInstance)
242  return false;
243 
244  ASTContext &Ctx = M.getState()->getStateManager().getContext();
245  initIdentifierInfoAndSelectors(Ctx);
246 
247  return M.getSelector() == SELdealloc;
248 }
249 
250 std::shared_ptr<PathDiagnosticPiece>
251 SuperDeallocBRVisitor::VisitNode(const ExplodedNode *Succ,
252  const ExplodedNode *Pred,
253  BugReporterContext &BRC, BugReport &BR) {
254  if (Satisfied)
255  return nullptr;
256 
257  ProgramStateRef State = Succ->getState();
258 
259  bool CalledNow =
260  Succ->getState()->contains<CalledSuperDealloc>(ReceiverSymbol);
261  bool CalledBefore =
262  Pred->getState()->contains<CalledSuperDealloc>(ReceiverSymbol);
263 
264  // Is Succ the node on which the analyzer noted that [super dealloc] was
265  // called on ReceiverSymbol?
266  if (CalledNow && !CalledBefore) {
267  Satisfied = true;
268 
269  ProgramPoint P = Succ->getLocation();
272 
273  if (!L.isValid() || !L.asLocation().isValid())
274  return nullptr;
275 
276  return std::make_shared<PathDiagnosticEventPiece>(
277  L, "[super dealloc] called here");
278  }
279 
280  return nullptr;
281 }
282 
283 //===----------------------------------------------------------------------===//
284 // Checker Registration.
285 //===----------------------------------------------------------------------===//
286 
287 void ento::registerObjCSuperDeallocChecker(CheckerManager &Mgr) {
288  const LangOptions &LangOpts = Mgr.getLangOpts();
289  if (LangOpts.getGC() == LangOptions::GCOnly || LangOpts.ObjCAutoRefCount)
290  return;
291  Mgr.registerChecker<ObjCSuperDeallocChecker>();
292 }
SVal getSelfSVal() const
Return the value of &#39;self&#39; if available.
Definition: CallEvent.cpp:740
SVal getReceiverSVal() const
Returns the value of the receiver at the time of this call.
Definition: CallEvent.cpp:748
const char *const CoreFoundationObjectiveC
Smart pointer class that efficiently represents Objective-C method names.
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:79
ExplodedNode * generateErrorNode(ProgramStateRef State=nullptr, const ProgramPointTag *Tag=nullptr)
Generate a transition to a node that will be used to report an error.
SymbolRef getLocSymbolInBase() const
Get the symbol in the SVal or its base region.
Definition: SVals.cpp:90
Stmt - This represents one statement.
Definition: Stmt.h:66
ExplodedNode * addTransition(ProgramStateRef State=nullptr, const ProgramPointTag *Tag=nullptr)
Generates a new transition in the program state graph (ExplodedGraph).
StringRef P
const ProgramStateRef & getState() const
#define REGISTER_SET_WITH_PROGRAMSTATE(Name, Elem)
Declares an immutable set of type NameTy, suitable for placement into the ProgramState.
Symbolic value.
Definition: SymExpr.h:29
One of these records is kept for each identifier that is lexed.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
LineState State
This class provides a convenience implementation for clone() using the Curiously-Recurring Template P...
virtual const Expr * getArgExpr(unsigned Index) const
Returns the expression associated with a given argument.
Definition: CallEvent.h:275
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
IdentifierTable & Idents
Definition: ASTContext.h:537
Represents any expression that calls an Objective-C method.
Definition: CallEvent.h:870
SymbolRef getAsSymbol(bool IncludeBaseRegions=false) const
If this SVal wraps a symbol return that SymbolRef.
Definition: SVals.cpp:116
SymbolicRegion - A special, "non-concrete" region.
Definition: MemRegion.h:742
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1187
void emitReport(std::unique_ptr< BugReport > R)
Emit the diagnostics report.
#define false
Definition: stdbool.h:33
SelectorTable & Selectors
Definition: ASTContext.h:538
CHECKER * registerChecker()
Used to register checkers.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
const MemRegion * getAsRegion() const
Definition: SVals.cpp:140
ProgramPoint getLocation() const
getLocation - Returns the edge associated with the given node.
SVal - This represents a symbolic expression, which can be either an L-value or an R-value...
Definition: SVals.h:63
virtual const ObjCMessageExpr * getOriginExpr() const
Definition: CallEvent.h:893
Selector getSelector() const
Definition: CallEvent.h:912
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
Represents an abstract call to a function or method along a particular path.
Definition: CallEvent.h:140
SubRegion - A region that subsets another larger region.
Definition: MemRegion.h:419
const ProgramStateRef & getState() const
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
virtual unsigned getNumArgs() const =0
Returns the number of arguments (explicit and implicit).
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:265
virtual SVal getArgSVal(unsigned Index) const
Returns the value of a given argument at the time of the call.
Definition: CallEvent.cpp:228
This class provides an interface through which checkers can create individual bug reports...
Definition: BugReporter.h:55
const LangOptions & getLangOpts() const
SourceManager & getSourceManager()
Definition: BugReporter.h:565