1//===--- TransRetainReleaseDealloc.cpp - Transformations to ARC mode ------===//
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// removeRetainReleaseDealloc:
10//
11// Removes retain/release/autorelease/dealloc messages.
12//
13//  return [[foo retain] autorelease];
14// ---->
15//  return foo;
16//
17//===----------------------------------------------------------------------===//
18
19#include "Transforms.h"
20#include "Internals.h"
21#include "clang/AST/ASTContext.h"
22#include "clang/AST/ParentMap.h"
23#include "clang/Basic/SourceManager.h"
24#include "clang/Lex/Lexer.h"
25#include "clang/Sema/SemaDiagnostic.h"
26#include "llvm/ADT/StringSwitch.h"
27
28using namespace clang;
29using namespace arcmt;
30using namespace trans;
31
32namespace {
33
34class RetainReleaseDeallocRemover :
35                       public RecursiveASTVisitor<RetainReleaseDeallocRemover> {
36  Stmt *Body;
37  MigrationPass &Pass;
38
39  ExprSet Removables;
40  std::unique_ptr<ParentMap> StmtMap;
41
42  Selector DelegateSel, FinalizeSel;
43
44public:
45  RetainReleaseDeallocRemover(MigrationPass &pass)
46    : Body(nullptr), Pass(pass) {
47    DelegateSel =
48        Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("delegate"));
49    FinalizeSel =
50        Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
51  }
52
53  void transformBody(Stmt *body, Decl *ParentD) {
54    Body = body;
55    collectRemovables(body, Removables);
56    StmtMap.reset(new ParentMap(body));
57    TraverseStmt(body);
58  }
59
60  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
61    switch (E->getMethodFamily()) {
62    default:
63      if (E->isInstanceMessage() && E->getSelector() == FinalizeSel)
64        break;
65      return true;
66    case OMF_autorelease:
67      if (isRemovable(E)) {
68        if (!isCommonUnusedAutorelease(E)) {
69          // An unused autorelease is badness. If we remove it the receiver
70          // will likely die immediately while previously it was kept alive
71          // by the autorelease pool. This is bad practice in general, leave it
72          // and emit an error to force the user to restructure their code.
73          Pass.TA.reportError(
74              "it is not safe to remove an unused 'autorelease' "
75              "message; its receiver may be destroyed immediately",
76              E->getBeginLoc(), E->getSourceRange());
77          return true;
78        }
79      }
80      // Pass through.
81      [[fallthrough]];
82    case OMF_retain:
83    case OMF_release:
84      if (E->getReceiverKind() == ObjCMessageExpr::Instance)
85        if (Expr *rec = E->getInstanceReceiver()) {
86          rec = rec->IgnoreParenImpCasts();
87          if (rec->getType().getObjCLifetime() == Qualifiers::OCL_ExplicitNone &&
88              (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
89            std::string err = "it is not safe to remove '";
90            err += E->getSelector().getAsString() + "' message on "
91                "an __unsafe_unretained type";
92            Pass.TA.reportError(err, rec->getBeginLoc());
93            return true;
94          }
95
96          if (isGlobalVar(rec) &&
97              (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
98            std::string err = "it is not safe to remove '";
99            err += E->getSelector().getAsString() + "' message on "
100                "a global variable";
101            Pass.TA.reportError(err, rec->getBeginLoc());
102            return true;
103          }
104
105          if (E->getMethodFamily() == OMF_release && isDelegateMessage(rec)) {
106            Pass.TA.reportError(
107                "it is not safe to remove 'retain' "
108                "message on the result of a 'delegate' message; "
109                "the object that was passed to 'setDelegate:' may not be "
110                "properly retained",
111                rec->getBeginLoc());
112            return true;
113          }
114        }
115      break;
116    case OMF_dealloc:
117      break;
118    }
119
120    switch (E->getReceiverKind()) {
121    default:
122      return true;
123    case ObjCMessageExpr::SuperInstance: {
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    }
131    case ObjCMessageExpr::Instance:
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
163private:
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<FullExpr>(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 (auto *E = dyn_cast_or_null<Expr>(prevStmt))
273        prevStmt = E->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 (auto *E = dyn_cast_or_null<Expr>(nextStmt))
284      nextStmt = E->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;
330    SourceManager &SM = Pass.Ctx.getSourceManager();
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 (FullExpr *FE = dyn_cast<FullExpr>(Rec))
380      Rec = FE->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
456void trans::removeRetainReleaseDeallocFinalize(MigrationPass &pass) {
457  BodyTransform<RetainReleaseDeallocRemover> trans(pass);
458  trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
459}
460