1 //===--- TransRetainReleaseDealloc.cpp - Transformations to ARC mode ------===//
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 // removeRetainReleaseDealloc:
12 // Removes retain/release/autorelease/dealloc messages.
14 // return [[foo retain] autorelease];
18 //===----------------------------------------------------------------------===//
20 #include "Transforms.h"
21 #include "Internals.h"
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/ParentMap.h"
24 #include "clang/Basic/SourceManager.h"
25 #include "clang/Lex/Lexer.h"
26 #include "clang/Sema/SemaDiagnostic.h"
27 #include "llvm/ADT/StringSwitch.h"
29 using namespace clang;
30 using namespace arcmt;
31 using namespace trans;
35 class RetainReleaseDeallocRemover :
36 public RecursiveASTVisitor<RetainReleaseDeallocRemover> {
41 std::unique_ptr<ParentMap> StmtMap;
43 Selector DelegateSel, FinalizeSel;
46 RetainReleaseDeallocRemover(MigrationPass &pass)
47 : Body(nullptr), Pass(pass) {
49 Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("delegate"));
51 Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
54 void transformBody(Stmt *body, Decl *ParentD) {
56 collectRemovables(body, Removables);
57 StmtMap.reset(new ParentMap(body));
61 bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
62 switch (E->getMethodFamily()) {
64 if (E->isInstanceMessage() && E->getSelector() == FinalizeSel)
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());
83 if (E->getReceiverKind() == ObjCMessageExpr::Instance)
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());
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 "
100 Pass.TA.reportError(err, rec->getLocStart());
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());
116 switch (E->getReceiverKind()) {
119 case ObjCMessageExpr::SuperInstance: {
120 Transaction Trans(Pass.TA);
121 clearDiagnostics(E->getSelectorLoc(0));
124 Pass.TA.replace(E->getSourceRange(), "self");
127 case ObjCMessageExpr::Instance:
131 Expr *rec = E->getInstanceReceiver();
132 if (!rec) return true;
134 Transaction Trans(Pass.TA);
135 clearDiagnostics(E->getSelectorLoc(0));
137 ObjCMessageExpr *Msg = E;
138 Expr *RecContainer = Msg;
139 SourceRange RecRange = rec->getSourceRange();
140 checkForGCDOrXPC(Msg, RecContainer, rec, RecRange);
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);
153 if (!hasSideEffects(rec, Pass.Ctx)) {
154 if (tryRemoving(RecContainer))
157 Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
163 /// \brief Checks for idioms where an unused -autorelease is common.
165 /// Returns true for this idiom which is common in property
168 /// [backingValue autorelease];
169 /// backingValue = [newValue retain]; // in general a +1 assign
171 /// For these as well:
173 /// [[var retain] autorelease];
176 bool isCommonUnusedAutorelease(ObjCMessageExpr *E) {
177 if (isPlusOneAssignBeforeOrAfterAutorelease(E))
179 if (isReturnedAfterAutorelease(E))
184 bool isReturnedAfterAutorelease(ObjCMessageExpr *E) {
185 Expr *Rec = E->getInstanceReceiver();
189 Decl *RefD = getReferencedDecl(Rec);
193 Stmt *nextStmt = getNextStmt(E);
197 // Check for "return <variable>;".
199 if (ReturnStmt *RetS = dyn_cast<ReturnStmt>(nextStmt))
200 return RefD == getReferencedDecl(RetS->getRetValue());
205 bool isPlusOneAssignBeforeOrAfterAutorelease(ObjCMessageExpr *E) {
206 Expr *Rec = E->getInstanceReceiver();
210 Decl *RefD = getReferencedDecl(Rec);
214 Stmt *prevStmt, *nextStmt;
215 std::tie(prevStmt, nextStmt) = getPreviousAndNextStmt(E);
217 return isPlusOneAssignToVar(prevStmt, RefD) ||
218 isPlusOneAssignToVar(nextStmt, RefD);
221 bool isPlusOneAssignToVar(Stmt *S, Decl *RefD) {
225 // Check for "RefD = [+1 retained object];".
227 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(S)) {
228 if (RefD != getReferencedDecl(Bop->getLHS()))
230 if (isPlusOneAssign(Bop))
235 if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
236 if (DS->isSingleDecl() && DS->getSingleDecl() == RefD) {
237 if (VarDecl *VD = dyn_cast<VarDecl>(RefD))
238 return isPlusOne(VD->getInit());
246 Stmt *getNextStmt(Expr *E) {
247 return getPreviousAndNextStmt(E).second;
250 std::pair<Stmt *, Stmt *> getPreviousAndNextStmt(Expr *E) {
251 Stmt *prevStmt = nullptr, *nextStmt = nullptr;
253 return std::make_pair(prevStmt, nextStmt);
255 Stmt *OuterS = E, *InnerS;
258 OuterS = StmtMap->getParent(InnerS);
260 while (OuterS && (isa<ParenExpr>(OuterS) ||
261 isa<CastExpr>(OuterS) ||
262 isa<ExprWithCleanups>(OuterS)));
265 return std::make_pair(prevStmt, nextStmt);
267 Stmt::child_iterator currChildS = OuterS->child_begin();
268 Stmt::child_iterator childE = OuterS->child_end();
269 Stmt::child_iterator prevChildS = childE;
270 for (; currChildS != childE; ++currChildS) {
271 if (*currChildS == InnerS)
273 prevChildS = currChildS;
276 if (prevChildS != childE) {
277 prevStmt = *prevChildS;
279 prevStmt = prevStmt->IgnoreImplicit();
282 if (currChildS == childE)
283 return std::make_pair(prevStmt, nextStmt);
285 if (currChildS == childE)
286 return std::make_pair(prevStmt, nextStmt);
288 nextStmt = *currChildS;
290 nextStmt = nextStmt->IgnoreImplicit();
292 return std::make_pair(prevStmt, nextStmt);
295 Decl *getReferencedDecl(Expr *E) {
299 E = E->IgnoreParenCasts();
300 if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
301 switch (ME->getMethodFamily()) {
303 case OMF_autorelease:
306 return getReferencedDecl(ME->getInstanceReceiver());
311 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
312 return DRE->getDecl();
313 if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
314 return ME->getMemberDecl();
315 if (ObjCIvarRefExpr *IRE = dyn_cast<ObjCIvarRefExpr>(E))
316 return IRE->getDecl();
321 /// \brief Check if the retain/release is due to a GCD/XPC macro that are
324 /// #define dispatch_retain(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); (void)[_o retain]; })
325 /// #define dispatch_release(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); [_o release]; })
326 /// #define xpc_retain(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o retain]; })
327 /// #define xpc_release(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o release]; })
329 /// and return the top container which is the StmtExpr and the macro argument
331 void checkForGCDOrXPC(ObjCMessageExpr *Msg, Expr *&RecContainer,
332 Expr *&Rec, SourceRange &RecRange) {
333 SourceLocation Loc = Msg->getExprLoc();
334 if (!Loc.isMacroID())
336 SourceManager &SM = Pass.Ctx.getSourceManager();
337 StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM,
338 Pass.Ctx.getLangOpts());
339 bool isGCDOrXPC = llvm::StringSwitch<bool>(MacroName)
340 .Case("dispatch_retain", true)
341 .Case("dispatch_release", true)
342 .Case("xpc_retain", true)
343 .Case("xpc_release", true)
348 StmtExpr *StmtE = nullptr;
351 if (StmtExpr *SE = dyn_cast<StmtExpr>(S)) {
355 S = StmtMap->getParent(S);
361 Stmt::child_range StmtExprChild = StmtE->children();
364 CompoundStmt *CompS = dyn_cast_or_null<CompoundStmt>(*StmtExprChild);
368 Stmt::child_range CompStmtChild = CompS->children();
371 DeclStmt *DeclS = dyn_cast_or_null<DeclStmt>(*CompStmtChild);
374 if (!DeclS->isSingleDecl())
376 VarDecl *VD = dyn_cast_or_null<VarDecl>(DeclS->getSingleDecl());
379 Expr *Init = VD->getInit();
383 RecContainer = StmtE;
384 Rec = Init->IgnoreParenImpCasts();
385 if (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(Rec))
386 Rec = EWC->getSubExpr()->IgnoreParenImpCasts();
387 RecRange = Rec->getSourceRange();
388 if (SM.isMacroArgExpansion(RecRange.getBegin()))
389 RecRange.setBegin(SM.getImmediateSpellingLoc(RecRange.getBegin()));
390 if (SM.isMacroArgExpansion(RecRange.getEnd()))
391 RecRange.setEnd(SM.getImmediateSpellingLoc(RecRange.getEnd()));
394 void clearDiagnostics(SourceLocation loc) const {
395 Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message,
396 diag::err_unavailable,
397 diag::err_unavailable_message,
401 bool isDelegateMessage(Expr *E) const {
402 if (!E) return false;
404 E = E->IgnoreParenCasts();
406 // Also look through property-getter sugar.
407 if (PseudoObjectExpr *pseudoOp = dyn_cast<PseudoObjectExpr>(E))
408 E = pseudoOp->getResultExpr()->IgnoreImplicit();
410 if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
411 return (ME->isInstanceMessage() && ME->getSelector() == DelegateSel);
416 bool isInAtFinally(Expr *E) const {
420 if (isa<ObjCAtFinallyStmt>(S))
422 S = StmtMap->getParent(S);
428 bool isRemovable(Expr *E) const {
429 return Removables.count(E);
432 bool tryRemoving(Expr *E) const {
433 if (isRemovable(E)) {
434 Pass.TA.removeStmt(E);
438 Stmt *parent = StmtMap->getParent(E);
440 if (ImplicitCastExpr *castE = dyn_cast_or_null<ImplicitCastExpr>(parent))
441 return tryRemoving(castE);
443 if (ParenExpr *parenE = dyn_cast_or_null<ParenExpr>(parent))
444 return tryRemoving(parenE);
447 bopE = dyn_cast_or_null<BinaryOperator>(parent)) {
448 if (bopE->getOpcode() == BO_Comma && bopE->getLHS() == E &&
450 Pass.TA.replace(bopE->getSourceRange(), bopE->getRHS()->getSourceRange());
460 } // anonymous namespace
462 void trans::removeRetainReleaseDeallocFinalize(MigrationPass &pass) {
463 BodyTransform<RetainReleaseDeallocRemover> trans(pass);
464 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());