clang  3.9.0
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("it is not safe to remove an unused 'autorelease' "
75  "message; its receiver may be destroyed immediately",
76  E->getLocStart(), E->getSourceRange());
77  return true;
78  }
79  }
80  // Pass through.
81  case OMF_retain:
82  case OMF_release:
84  if (Expr *rec = E->getInstanceReceiver()) {
85  rec = rec->IgnoreParenImpCasts();
86  if (rec->getType().getObjCLifetime() == Qualifiers::OCL_ExplicitNone &&
87  (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
88  std::string err = "it is not safe to remove '";
89  err += E->getSelector().getAsString() + "' message on "
90  "an __unsafe_unretained type";
91  Pass.TA.reportError(err, rec->getLocStart());
92  return true;
93  }
94 
95  if (isGlobalVar(rec) &&
96  (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
97  std::string err = "it is not safe to remove '";
98  err += E->getSelector().getAsString() + "' message on "
99  "a global variable";
100  Pass.TA.reportError(err, rec->getLocStart());
101  return true;
102  }
103 
104  if (E->getMethodFamily() == OMF_release && isDelegateMessage(rec)) {
105  Pass.TA.reportError("it is not safe to remove 'retain' "
106  "message on the result of a 'delegate' message; "
107  "the object that was passed to 'setDelegate:' may not be "
108  "properly retained", rec->getLocStart());
109  return true;
110  }
111  }
112  case OMF_dealloc:
113  break;
114  }
115 
116  switch (E->getReceiverKind()) {
117  default:
118  return true;
120  Transaction Trans(Pass.TA);
121  clearDiagnostics(E->getSelectorLoc(0));
122  if (tryRemoving(E))
123  return true;
124  Pass.TA.replace(E->getSourceRange(), "self");
125  return true;
126  }
128  break;
129  }
130 
131  Expr *rec = E->getInstanceReceiver();
132  if (!rec) return true;
133 
134  Transaction Trans(Pass.TA);
135  clearDiagnostics(E->getSelectorLoc(0));
136 
137  ObjCMessageExpr *Msg = E;
138  Expr *RecContainer = Msg;
139  SourceRange RecRange = rec->getSourceRange();
140  checkForGCDOrXPC(Msg, RecContainer, rec, RecRange);
141 
142  if (Msg->getMethodFamily() == OMF_release &&
143  isRemovable(RecContainer) && isInAtFinally(RecContainer)) {
144  // Change the -release to "receiver = nil" in a finally to avoid a leak
145  // when an exception is thrown.
146  Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
147  std::string str = " = ";
148  str += getNilString(Pass);
149  Pass.TA.insertAfterToken(RecRange.getEnd(), str);
150  return true;
151  }
152 
153  if (hasSideEffects(rec, Pass.Ctx) || !tryRemoving(RecContainer))
154  Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
155 
156  return true;
157  }
158 
159 private:
160  /// \brief Checks for idioms where an unused -autorelease is common.
161  ///
162  /// Returns true for this idiom which is common in property
163  /// setters:
164  ///
165  /// [backingValue autorelease];
166  /// backingValue = [newValue retain]; // in general a +1 assign
167  ///
168  /// For these as well:
169  ///
170  /// [[var retain] autorelease];
171  /// return var;
172  ///
173  bool isCommonUnusedAutorelease(ObjCMessageExpr *E) {
174  return isPlusOneAssignBeforeOrAfterAutorelease(E) ||
175  isReturnedAfterAutorelease(E);
176  }
177 
178  bool isReturnedAfterAutorelease(ObjCMessageExpr *E) {
179  Expr *Rec = E->getInstanceReceiver();
180  if (!Rec)
181  return false;
182 
183  Decl *RefD = getReferencedDecl(Rec);
184  if (!RefD)
185  return false;
186 
187  Stmt *nextStmt = getNextStmt(E);
188  if (!nextStmt)
189  return false;
190 
191  // Check for "return <variable>;".
192 
193  if (ReturnStmt *RetS = dyn_cast<ReturnStmt>(nextStmt))
194  return RefD == getReferencedDecl(RetS->getRetValue());
195 
196  return false;
197  }
198 
199  bool isPlusOneAssignBeforeOrAfterAutorelease(ObjCMessageExpr *E) {
200  Expr *Rec = E->getInstanceReceiver();
201  if (!Rec)
202  return false;
203 
204  Decl *RefD = getReferencedDecl(Rec);
205  if (!RefD)
206  return false;
207 
208  Stmt *prevStmt, *nextStmt;
209  std::tie(prevStmt, nextStmt) = getPreviousAndNextStmt(E);
210 
211  return isPlusOneAssignToVar(prevStmt, RefD) ||
212  isPlusOneAssignToVar(nextStmt, RefD);
213  }
214 
215  bool isPlusOneAssignToVar(Stmt *S, Decl *RefD) {
216  if (!S)
217  return false;
218 
219  // Check for "RefD = [+1 retained object];".
220 
221  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(S)) {
222  return (RefD == getReferencedDecl(Bop->getLHS())) && isPlusOneAssign(Bop);
223  }
224 
225  if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
226  if (DS->isSingleDecl() && DS->getSingleDecl() == RefD) {
227  if (VarDecl *VD = dyn_cast<VarDecl>(RefD))
228  return isPlusOne(VD->getInit());
229  }
230  return false;
231  }
232 
233  return false;
234  }
235 
236  Stmt *getNextStmt(Expr *E) {
237  return getPreviousAndNextStmt(E).second;
238  }
239 
240  std::pair<Stmt *, Stmt *> getPreviousAndNextStmt(Expr *E) {
241  Stmt *prevStmt = nullptr, *nextStmt = nullptr;
242  if (!E)
243  return std::make_pair(prevStmt, nextStmt);
244 
245  Stmt *OuterS = E, *InnerS;
246  do {
247  InnerS = OuterS;
248  OuterS = StmtMap->getParent(InnerS);
249  }
250  while (OuterS && (isa<ParenExpr>(OuterS) ||
251  isa<CastExpr>(OuterS) ||
252  isa<ExprWithCleanups>(OuterS)));
253 
254  if (!OuterS)
255  return std::make_pair(prevStmt, nextStmt);
256 
257  Stmt::child_iterator currChildS = OuterS->child_begin();
258  Stmt::child_iterator childE = OuterS->child_end();
259  Stmt::child_iterator prevChildS = childE;
260  for (; currChildS != childE; ++currChildS) {
261  if (*currChildS == InnerS)
262  break;
263  prevChildS = currChildS;
264  }
265 
266  if (prevChildS != childE) {
267  prevStmt = *prevChildS;
268  if (prevStmt)
269  prevStmt = prevStmt->IgnoreImplicit();
270  }
271 
272  if (currChildS == childE)
273  return std::make_pair(prevStmt, nextStmt);
274  ++currChildS;
275  if (currChildS == childE)
276  return std::make_pair(prevStmt, nextStmt);
277 
278  nextStmt = *currChildS;
279  if (nextStmt)
280  nextStmt = nextStmt->IgnoreImplicit();
281 
282  return std::make_pair(prevStmt, nextStmt);
283  }
284 
285  Decl *getReferencedDecl(Expr *E) {
286  if (!E)
287  return nullptr;
288 
289  E = E->IgnoreParenCasts();
290  if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
291  switch (ME->getMethodFamily()) {
292  case OMF_copy:
293  case OMF_autorelease:
294  case OMF_release:
295  case OMF_retain:
296  return getReferencedDecl(ME->getInstanceReceiver());
297  default:
298  return nullptr;
299  }
300  }
301  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
302  return DRE->getDecl();
303  if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
304  return ME->getMemberDecl();
305  if (ObjCIvarRefExpr *IRE = dyn_cast<ObjCIvarRefExpr>(E))
306  return IRE->getDecl();
307 
308  return nullptr;
309  }
310 
311  /// \brief Check if the retain/release is due to a GCD/XPC macro that are
312  /// defined as:
313  ///
314  /// #define dispatch_retain(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); (void)[_o retain]; })
315  /// #define dispatch_release(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); [_o release]; })
316  /// #define xpc_retain(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o retain]; })
317  /// #define xpc_release(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o release]; })
318  ///
319  /// and return the top container which is the StmtExpr and the macro argument
320  /// expression.
321  void checkForGCDOrXPC(ObjCMessageExpr *Msg, Expr *&RecContainer,
322  Expr *&Rec, SourceRange &RecRange) {
323  SourceLocation Loc = Msg->getExprLoc();
324  if (!Loc.isMacroID())
325  return;
326  SourceManager &SM = Pass.Ctx.getSourceManager();
327  StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM,
328  Pass.Ctx.getLangOpts());
329  bool isGCDOrXPC = llvm::StringSwitch<bool>(MacroName)
330  .Case("dispatch_retain", true)
331  .Case("dispatch_release", true)
332  .Case("xpc_retain", true)
333  .Case("xpc_release", true)
334  .Default(false);
335  if (!isGCDOrXPC)
336  return;
337 
338  StmtExpr *StmtE = nullptr;
339  Stmt *S = Msg;
340  while (S) {
341  if (StmtExpr *SE = dyn_cast<StmtExpr>(S)) {
342  StmtE = SE;
343  break;
344  }
345  S = StmtMap->getParent(S);
346  }
347 
348  if (!StmtE)
349  return;
350 
351  Stmt::child_range StmtExprChild = StmtE->children();
352  if (StmtExprChild.begin() == StmtExprChild.end())
353  return;
354  auto *CompS = dyn_cast_or_null<CompoundStmt>(*StmtExprChild.begin());
355  if (!CompS)
356  return;
357 
358  Stmt::child_range CompStmtChild = CompS->children();
359  if (CompStmtChild.begin() == CompStmtChild.end())
360  return;
361  auto *DeclS = dyn_cast_or_null<DeclStmt>(*CompStmtChild.begin());
362  if (!DeclS)
363  return;
364  if (!DeclS->isSingleDecl())
365  return;
366  VarDecl *VD = dyn_cast_or_null<VarDecl>(DeclS->getSingleDecl());
367  if (!VD)
368  return;
369  Expr *Init = VD->getInit();
370  if (!Init)
371  return;
372 
373  RecContainer = StmtE;
374  Rec = Init->IgnoreParenImpCasts();
375  if (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(Rec))
376  Rec = EWC->getSubExpr()->IgnoreParenImpCasts();
377  RecRange = Rec->getSourceRange();
378  if (SM.isMacroArgExpansion(RecRange.getBegin()))
379  RecRange.setBegin(SM.getImmediateSpellingLoc(RecRange.getBegin()));
380  if (SM.isMacroArgExpansion(RecRange.getEnd()))
381  RecRange.setEnd(SM.getImmediateSpellingLoc(RecRange.getEnd()));
382  }
383 
384  void clearDiagnostics(SourceLocation loc) const {
385  Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message,
386  diag::err_unavailable,
387  diag::err_unavailable_message,
388  loc);
389  }
390 
391  bool isDelegateMessage(Expr *E) const {
392  if (!E) return false;
393 
394  E = E->IgnoreParenCasts();
395 
396  // Also look through property-getter sugar.
397  if (PseudoObjectExpr *pseudoOp = dyn_cast<PseudoObjectExpr>(E))
398  E = pseudoOp->getResultExpr()->IgnoreImplicit();
399 
400  if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
401  return (ME->isInstanceMessage() && ME->getSelector() == DelegateSel);
402 
403  return false;
404  }
405 
406  bool isInAtFinally(Expr *E) const {
407  assert(E);
408  Stmt *S = E;
409  while (S) {
410  if (isa<ObjCAtFinallyStmt>(S))
411  return true;
412  S = StmtMap->getParent(S);
413  }
414 
415  return false;
416  }
417 
418  bool isRemovable(Expr *E) const {
419  return Removables.count(E);
420  }
421 
422  bool tryRemoving(Expr *E) const {
423  if (isRemovable(E)) {
424  Pass.TA.removeStmt(E);
425  return true;
426  }
427 
428  Stmt *parent = StmtMap->getParent(E);
429 
430  if (ImplicitCastExpr *castE = dyn_cast_or_null<ImplicitCastExpr>(parent))
431  return tryRemoving(castE);
432 
433  if (ParenExpr *parenE = dyn_cast_or_null<ParenExpr>(parent))
434  return tryRemoving(parenE);
435 
436  if (BinaryOperator *
437  bopE = dyn_cast_or_null<BinaryOperator>(parent)) {
438  if (bopE->getOpcode() == BO_Comma && bopE->getLHS() == E &&
439  isRemovable(bopE)) {
440  Pass.TA.replace(bopE->getSourceRange(), bopE->getRHS()->getSourceRange());
441  return true;
442  }
443  }
444 
445  return false;
446  }
447 
448 };
449 
450 } // anonymous namespace
451 
455 }
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1009
bool isMacroArgExpansion(SourceLocation Loc, SourceLocation *StartLoc=nullptr) const
Tests whether the given source location represents a macro argument's expansion into the function-lik...
Defines the clang::ASTContext interface.
SourceLocation getEnd() const
The receiver is an object instance.
Definition: ExprObjC.h:1005
Smart pointer class that efficiently represents Objective-C method names.
bool isMacroID() const
ObjCMethodFamily getMethodFamily() const
Definition: ExprObjC.h:1270
SourceLocation getImmediateSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
Defines the SourceManager interface.
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1619
const Expr * getInit() const
Definition: Decl.h:1139
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
Expr * IgnoreImplicit() LLVM_READONLY
IgnoreImplicit - Skip past any implicit AST nodes which might surround this expression.
Definition: Expr.h:724
void setBegin(SourceLocation b)
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:2936
child_range children()
Definition: Expr.h:3413
bool TraverseDecl(Decl *D)
Recursively visit a declaration, by dispatching to Traverse*Decl() based on the argument's dynamic ty...
bool isGlobalVar(Expr *E)
Definition: Transforms.cpp:202
void removeRetainReleaseDeallocFinalize(MigrationPass &pass)
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2897
Selector getSelector() const
Definition: ExprObjC.cpp:306
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2326
A class that does preordor or postorder depth-first traversal on the entire Clang AST and visits each...
bool isPlusOneAssign(const BinaryOperator *E)
Definition: Transforms.cpp:72
This object can be modified without requiring retains or releases.
Definition: Type.h:138
StringRef getNilString(MigrationPass &Pass)
Returns "nil" or "0" if 'nil' macro is not actually defined.
Definition: Transforms.cpp:214
bool isInstanceMessage() const
Determine whether this is an instance message to either a computed object or to super.
Definition: ExprObjC.h:1143
void collectRemovables(Stmt *S, ExprSet &exprs)
Definition: Transforms.cpp:313
Expr - This represents one expression.
Definition: Expr.h:105
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:886
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1366
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
const SourceManager & SM
Definition: Format.cpp:1184
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4679
Encodes a location in the source.
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:443
std::string getAsString() const
Derive the full selector name (e.g.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2734
SourceLocation getBegin() const
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3380
static StringRef getImmediateMacroName(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
Definition: Lexer.cpp:958
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:193
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1155
bool hasSideEffects(Expr *E, ASTContext &Ctx)
Definition: Transforms.cpp:173
SourceLocation getSelectorLoc(unsigned Index) const
Definition: ExprObjC.h:1318
SourceLocation getLocStart() const LLVM_READONLY
Definition: ExprObjC.h:1344
bool isPlusOne(const Expr *E)
Definition: Transforms.cpp:79
detail::InMemoryDirectory::const_iterator E
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2413
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:479
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2315
void setEnd(SourceLocation e)
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:932
A trivial tuple used to represent a source range.
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1136
This class handles loading and caching of source files into memory.