clang  8.0.0svn
TransRetainReleaseDealloc.cpp
Go to the documentation of this file.
1 //===--- TransRetainReleaseDealloc.cpp - Transformations to ARC mode ------===//
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 // removeRetainReleaseDealloc:
11 //
12 // Removes retain/release/autorelease/dealloc messages.
13 //
14 // return [[foo retain] autorelease];
15 // ---->
16 // return foo;
17 //
18 //===----------------------------------------------------------------------===//
19 
20 #include "Transforms.h"
21 #include "Internals.h"
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/ParentMap.h"
25 #include "clang/Lex/Lexer.h"
27 #include "llvm/ADT/StringSwitch.h"
28 
29 using namespace clang;
30 using namespace arcmt;
31 using namespace trans;
32 
33 namespace {
34 
35 class RetainReleaseDeallocRemover :
36  public RecursiveASTVisitor<RetainReleaseDeallocRemover> {
37  Stmt *Body;
38  MigrationPass &Pass;
39 
40  ExprSet Removables;
41  std::unique_ptr<ParentMap> StmtMap;
42 
43  Selector DelegateSel, FinalizeSel;
44 
45 public:
46  RetainReleaseDeallocRemover(MigrationPass &pass)
47  : Body(nullptr), Pass(pass) {
48  DelegateSel =
49  Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("delegate"));
50  FinalizeSel =
51  Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
52  }
53 
54  void transformBody(Stmt *body, Decl *ParentD) {
55  Body = body;
56  collectRemovables(body, Removables);
57  StmtMap.reset(new ParentMap(body));
58  TraverseStmt(body);
59  }
60 
61  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
62  switch (E->getMethodFamily()) {
63  default:
64  if (E->isInstanceMessage() && E->getSelector() == FinalizeSel)
65  break;
66  return true;
67  case OMF_autorelease:
68  if (isRemovable(E)) {
69  if (!isCommonUnusedAutorelease(E)) {
70  // An unused autorelease is badness. If we remove it the receiver
71  // will likely die immediately while previously it was kept alive
72  // by the autorelease pool. This is bad practice in general, leave it
73  // and emit an error to force the user to restructure their code.
74  Pass.TA.reportError(
75  "it is not safe to remove an unused 'autorelease' "
76  "message; its receiver may be destroyed immediately",
77  E->getBeginLoc(), E->getSourceRange());
78  return true;
79  }
80  }
81  // Pass through.
82  LLVM_FALLTHROUGH;
83  case OMF_retain:
84  case OMF_release:
86  if (Expr *rec = E->getInstanceReceiver()) {
87  rec = rec->IgnoreParenImpCasts();
88  if (rec->getType().getObjCLifetime() == Qualifiers::OCL_ExplicitNone &&
89  (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
90  std::string err = "it is not safe to remove '";
91  err += E->getSelector().getAsString() + "' message on "
92  "an __unsafe_unretained type";
93  Pass.TA.reportError(err, rec->getBeginLoc());
94  return true;
95  }
96 
97  if (isGlobalVar(rec) &&
98  (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
99  std::string err = "it is not safe to remove '";
100  err += E->getSelector().getAsString() + "' message on "
101  "a global variable";
102  Pass.TA.reportError(err, rec->getBeginLoc());
103  return true;
104  }
105 
106  if (E->getMethodFamily() == OMF_release && isDelegateMessage(rec)) {
107  Pass.TA.reportError(
108  "it is not safe to remove 'retain' "
109  "message on the result of a 'delegate' message; "
110  "the object that was passed to 'setDelegate:' may not be "
111  "properly retained",
112  rec->getBeginLoc());
113  return true;
114  }
115  }
116  case OMF_dealloc:
117  break;
118  }
119 
120  switch (E->getReceiverKind()) {
121  default:
122  return true;
124  Transaction Trans(Pass.TA);
125  clearDiagnostics(E->getSelectorLoc(0));
126  if (tryRemoving(E))
127  return true;
128  Pass.TA.replace(E->getSourceRange(), "self");
129  return true;
130  }
132  break;
133  }
134 
135  Expr *rec = E->getInstanceReceiver();
136  if (!rec) return true;
137 
138  Transaction Trans(Pass.TA);
139  clearDiagnostics(E->getSelectorLoc(0));
140 
141  ObjCMessageExpr *Msg = E;
142  Expr *RecContainer = Msg;
143  SourceRange RecRange = rec->getSourceRange();
144  checkForGCDOrXPC(Msg, RecContainer, rec, RecRange);
145 
146  if (Msg->getMethodFamily() == OMF_release &&
147  isRemovable(RecContainer) && isInAtFinally(RecContainer)) {
148  // Change the -release to "receiver = nil" in a finally to avoid a leak
149  // when an exception is thrown.
150  Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
151  std::string str = " = ";
152  str += getNilString(Pass);
153  Pass.TA.insertAfterToken(RecRange.getEnd(), str);
154  return true;
155  }
156 
157  if (hasSideEffects(rec, Pass.Ctx) || !tryRemoving(RecContainer))
158  Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
159 
160  return true;
161  }
162 
163 private:
164  /// Checks for idioms where an unused -autorelease is common.
165  ///
166  /// Returns true for this idiom which is common in property
167  /// setters:
168  ///
169  /// [backingValue autorelease];
170  /// backingValue = [newValue retain]; // in general a +1 assign
171  ///
172  /// For these as well:
173  ///
174  /// [[var retain] autorelease];
175  /// return var;
176  ///
177  bool isCommonUnusedAutorelease(ObjCMessageExpr *E) {
178  return isPlusOneAssignBeforeOrAfterAutorelease(E) ||
179  isReturnedAfterAutorelease(E);
180  }
181 
182  bool isReturnedAfterAutorelease(ObjCMessageExpr *E) {
183  Expr *Rec = E->getInstanceReceiver();
184  if (!Rec)
185  return false;
186 
187  Decl *RefD = getReferencedDecl(Rec);
188  if (!RefD)
189  return false;
190 
191  Stmt *nextStmt = getNextStmt(E);
192  if (!nextStmt)
193  return false;
194 
195  // Check for "return <variable>;".
196 
197  if (ReturnStmt *RetS = dyn_cast<ReturnStmt>(nextStmt))
198  return RefD == getReferencedDecl(RetS->getRetValue());
199 
200  return false;
201  }
202 
203  bool isPlusOneAssignBeforeOrAfterAutorelease(ObjCMessageExpr *E) {
204  Expr *Rec = E->getInstanceReceiver();
205  if (!Rec)
206  return false;
207 
208  Decl *RefD = getReferencedDecl(Rec);
209  if (!RefD)
210  return false;
211 
212  Stmt *prevStmt, *nextStmt;
213  std::tie(prevStmt, nextStmt) = getPreviousAndNextStmt(E);
214 
215  return isPlusOneAssignToVar(prevStmt, RefD) ||
216  isPlusOneAssignToVar(nextStmt, RefD);
217  }
218 
219  bool isPlusOneAssignToVar(Stmt *S, Decl *RefD) {
220  if (!S)
221  return false;
222 
223  // Check for "RefD = [+1 retained object];".
224 
225  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(S)) {
226  return (RefD == getReferencedDecl(Bop->getLHS())) && isPlusOneAssign(Bop);
227  }
228 
229  if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
230  if (DS->isSingleDecl() && DS->getSingleDecl() == RefD) {
231  if (VarDecl *VD = dyn_cast<VarDecl>(RefD))
232  return isPlusOne(VD->getInit());
233  }
234  return false;
235  }
236 
237  return false;
238  }
239 
240  Stmt *getNextStmt(Expr *E) {
241  return getPreviousAndNextStmt(E).second;
242  }
243 
244  std::pair<Stmt *, Stmt *> getPreviousAndNextStmt(Expr *E) {
245  Stmt *prevStmt = nullptr, *nextStmt = nullptr;
246  if (!E)
247  return std::make_pair(prevStmt, nextStmt);
248 
249  Stmt *OuterS = E, *InnerS;
250  do {
251  InnerS = OuterS;
252  OuterS = StmtMap->getParent(InnerS);
253  }
254  while (OuterS && (isa<ParenExpr>(OuterS) ||
255  isa<CastExpr>(OuterS) ||
256  isa<ExprWithCleanups>(OuterS)));
257 
258  if (!OuterS)
259  return std::make_pair(prevStmt, nextStmt);
260 
261  Stmt::child_iterator currChildS = OuterS->child_begin();
262  Stmt::child_iterator childE = OuterS->child_end();
263  Stmt::child_iterator prevChildS = childE;
264  for (; currChildS != childE; ++currChildS) {
265  if (*currChildS == InnerS)
266  break;
267  prevChildS = currChildS;
268  }
269 
270  if (prevChildS != childE) {
271  prevStmt = *prevChildS;
272  if (prevStmt)
273  prevStmt = prevStmt->IgnoreImplicit();
274  }
275 
276  if (currChildS == childE)
277  return std::make_pair(prevStmt, nextStmt);
278  ++currChildS;
279  if (currChildS == childE)
280  return std::make_pair(prevStmt, nextStmt);
281 
282  nextStmt = *currChildS;
283  if (nextStmt)
284  nextStmt = nextStmt->IgnoreImplicit();
285 
286  return std::make_pair(prevStmt, nextStmt);
287  }
288 
289  Decl *getReferencedDecl(Expr *E) {
290  if (!E)
291  return nullptr;
292 
293  E = E->IgnoreParenCasts();
294  if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
295  switch (ME->getMethodFamily()) {
296  case OMF_copy:
297  case OMF_autorelease:
298  case OMF_release:
299  case OMF_retain:
300  return getReferencedDecl(ME->getInstanceReceiver());
301  default:
302  return nullptr;
303  }
304  }
305  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
306  return DRE->getDecl();
307  if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
308  return ME->getMemberDecl();
309  if (ObjCIvarRefExpr *IRE = dyn_cast<ObjCIvarRefExpr>(E))
310  return IRE->getDecl();
311 
312  return nullptr;
313  }
314 
315  /// Check if the retain/release is due to a GCD/XPC macro that are
316  /// defined as:
317  ///
318  /// #define dispatch_retain(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); (void)[_o retain]; })
319  /// #define dispatch_release(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); [_o release]; })
320  /// #define xpc_retain(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o retain]; })
321  /// #define xpc_release(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o release]; })
322  ///
323  /// and return the top container which is the StmtExpr and the macro argument
324  /// expression.
325  void checkForGCDOrXPC(ObjCMessageExpr *Msg, Expr *&RecContainer,
326  Expr *&Rec, SourceRange &RecRange) {
327  SourceLocation Loc = Msg->getExprLoc();
328  if (!Loc.isMacroID())
329  return;
331  StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM,
332  Pass.Ctx.getLangOpts());
333  bool isGCDOrXPC = llvm::StringSwitch<bool>(MacroName)
334  .Case("dispatch_retain", true)
335  .Case("dispatch_release", true)
336  .Case("xpc_retain", true)
337  .Case("xpc_release", true)
338  .Default(false);
339  if (!isGCDOrXPC)
340  return;
341 
342  StmtExpr *StmtE = nullptr;
343  Stmt *S = Msg;
344  while (S) {
345  if (StmtExpr *SE = dyn_cast<StmtExpr>(S)) {
346  StmtE = SE;
347  break;
348  }
349  S = StmtMap->getParent(S);
350  }
351 
352  if (!StmtE)
353  return;
354 
355  Stmt::child_range StmtExprChild = StmtE->children();
356  if (StmtExprChild.begin() == StmtExprChild.end())
357  return;
358  auto *CompS = dyn_cast_or_null<CompoundStmt>(*StmtExprChild.begin());
359  if (!CompS)
360  return;
361 
362  Stmt::child_range CompStmtChild = CompS->children();
363  if (CompStmtChild.begin() == CompStmtChild.end())
364  return;
365  auto *DeclS = dyn_cast_or_null<DeclStmt>(*CompStmtChild.begin());
366  if (!DeclS)
367  return;
368  if (!DeclS->isSingleDecl())
369  return;
370  VarDecl *VD = dyn_cast_or_null<VarDecl>(DeclS->getSingleDecl());
371  if (!VD)
372  return;
373  Expr *Init = VD->getInit();
374  if (!Init)
375  return;
376 
377  RecContainer = StmtE;
378  Rec = Init->IgnoreParenImpCasts();
379  if (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(Rec))
380  Rec = EWC->getSubExpr()->IgnoreParenImpCasts();
381  RecRange = Rec->getSourceRange();
382  if (SM.isMacroArgExpansion(RecRange.getBegin()))
383  RecRange.setBegin(SM.getImmediateSpellingLoc(RecRange.getBegin()));
384  if (SM.isMacroArgExpansion(RecRange.getEnd()))
385  RecRange.setEnd(SM.getImmediateSpellingLoc(RecRange.getEnd()));
386  }
387 
388  void clearDiagnostics(SourceLocation loc) const {
389  Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message,
390  diag::err_unavailable,
391  diag::err_unavailable_message,
392  loc);
393  }
394 
395  bool isDelegateMessage(Expr *E) const {
396  if (!E) return false;
397 
398  E = E->IgnoreParenCasts();
399 
400  // Also look through property-getter sugar.
401  if (PseudoObjectExpr *pseudoOp = dyn_cast<PseudoObjectExpr>(E))
402  E = pseudoOp->getResultExpr()->IgnoreImplicit();
403 
404  if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
405  return (ME->isInstanceMessage() && ME->getSelector() == DelegateSel);
406 
407  return false;
408  }
409 
410  bool isInAtFinally(Expr *E) const {
411  assert(E);
412  Stmt *S = E;
413  while (S) {
414  if (isa<ObjCAtFinallyStmt>(S))
415  return true;
416  S = StmtMap->getParent(S);
417  }
418 
419  return false;
420  }
421 
422  bool isRemovable(Expr *E) const {
423  return Removables.count(E);
424  }
425 
426  bool tryRemoving(Expr *E) const {
427  if (isRemovable(E)) {
428  Pass.TA.removeStmt(E);
429  return true;
430  }
431 
432  Stmt *parent = StmtMap->getParent(E);
433 
434  if (ImplicitCastExpr *castE = dyn_cast_or_null<ImplicitCastExpr>(parent))
435  return tryRemoving(castE);
436 
437  if (ParenExpr *parenE = dyn_cast_or_null<ParenExpr>(parent))
438  return tryRemoving(parenE);
439 
440  if (BinaryOperator *
441  bopE = dyn_cast_or_null<BinaryOperator>(parent)) {
442  if (bopE->getOpcode() == BO_Comma && bopE->getLHS() == E &&
443  isRemovable(bopE)) {
444  Pass.TA.replace(bopE->getSourceRange(), bopE->getRHS()->getSourceRange());
445  return true;
446  }
447  }
448 
449  return false;
450  }
451 
452 };
453 
454 } // anonymous namespace
455 
459 }
child_iterator child_begin()
Definition: Stmt.h:470
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1061
Defines the clang::ASTContext interface.
The receiver is an object instance.
Definition: ExprObjC.h:1055
Smart pointer class that efficiently represents Objective-C method names.
Selector getSelector() const
Definition: ExprObjC.cpp:312
Stmt - This represents one statement.
Definition: Stmt.h:66
Defines the SourceManager interface.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1732
llvm::iterator_range< child_iterator > child_range
Definition: Stmt.h:460
Stmt * IgnoreImplicit()
Skip past any implicit AST nodes which might surround this statement, such as ExprWithCleanups or Imp...
Definition: Stmt.cpp:113
Represents a variable declaration or definition.
Definition: Decl.h:812
Expr * IgnoreImplicit() LLVM_READONLY
IgnoreImplicit - Skip past any implicit AST nodes which might surround this expression.
Definition: Expr.h:740
void setBegin(SourceLocation b)
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3033
child_range children()
Definition: Expr.h:3644
bool TraverseDecl(Decl *D)
Recursively visit a declaration, by dispatching to Traverse*Decl() based on the argument&#39;s dynamic ty...
bool isGlobalVar(Expr *E)
Definition: Transforms.cpp:197
void reportError(StringRef error, SourceLocation loc, SourceRange range=SourceRange())
IdentifierTable & Idents
Definition: ASTContext.h:565
Selector getNullarySelector(IdentifierInfo *ID)
void removeRetainReleaseDeallocFinalize(MigrationPass &pass)
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3102
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2544
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
bool isPlusOneAssign(const BinaryOperator *E)
Definition: Transforms.cpp:67
This object can be modified without requiring retains or releases.
Definition: Type.h:162
return Out str()
StringRef getNilString(MigrationPass &Pass)
Returns "nil" or "0" if &#39;nil&#39; macro is not actually defined.
Definition: Transforms.cpp:209
bool clearDiagnostic(ArrayRef< unsigned > IDs, SourceRange range)
void collectRemovables(Stmt *S, ExprSet &exprs)
Definition: Transforms.cpp:308
SourceLocation getImmediateSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
This represents one expression.
Definition: Expr.h:105
void insertAfterToken(SourceLocation loc, StringRef text)
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1444
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:904
SourceLocation getEnd() const
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1188
const SourceManager & SM
Definition: Format.cpp:1490
std::string getAsString() const
Derive the full selector name (e.g.
SelectorTable & Selectors
Definition: ASTContext.h:566
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5096
Encodes a location in the source.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ObjCMethodFamily getMethodFamily() const
Definition: ExprObjC.h:1322
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:505
SourceLocation getSelectorLoc(unsigned Index) const
Definition: ExprObjC.h:1372
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2924
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3611
static StringRef getImmediateMacroName(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
Definition: Lexer.cpp:968
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1207
Dataflow Directional Tag Classes.
bool hasSideEffects(Expr *E, ASTContext &Ctx)
Definition: Transforms.cpp:168
const Expr * getInit() const
Definition: Decl.h:1219
bool isPlusOne(const Expr *E)
Definition: Transforms.cpp:74
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2631
bool isMacroArgExpansion(SourceLocation Loc, SourceLocation *StartLoc=nullptr) const
Tests whether the given source location represents a macro argument&#39;s expansion into the function-lik...
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:513
SourceManager & getSourceManager()
Definition: ASTContext.h:671
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1018
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2467
void replace(SourceRange range, StringRef text)
TransformActions & TA
Definition: Internals.h:151
void setEnd(SourceLocation e)
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:1399
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:268
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:971
A trivial tuple used to represent a source range.
bool isInstanceMessage() const
Determine whether this is an instance message to either a computed object or to super.
Definition: ExprObjC.h:1195
SourceLocation getBegin() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:716
This class handles loading and caching of source files into memory.
child_iterator child_end()
Definition: Stmt.h:471