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"
24 #include "clang/Basic/SourceManager.h"
25 #include "clang/Lex/Lexer.h"
26 #include "clang/Sema/SemaDiagnostic.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:
RetainReleaseDeallocRemover(MigrationPass & pass)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
transformBody(Stmt * body,Decl * ParentD)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
VisitObjCMessageExpr(ObjCMessageExpr * E)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:
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());
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;
119 case ObjCMessageExpr::SuperInstance: {
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 }
127 case ObjCMessageExpr::Instance:
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 ///
isCommonUnusedAutorelease(ObjCMessageExpr * E)173 bool isCommonUnusedAutorelease(ObjCMessageExpr *E) {
174 return isPlusOneAssignBeforeOrAfterAutorelease(E) ||
175 isReturnedAfterAutorelease(E);
176 }
177
isReturnedAfterAutorelease(ObjCMessageExpr * E)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
isPlusOneAssignBeforeOrAfterAutorelease(ObjCMessageExpr * E)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
isPlusOneAssignToVar(Stmt * S,Decl * RefD)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
getNextStmt(Expr * E)236 Stmt *getNextStmt(Expr *E) {
237 return getPreviousAndNextStmt(E).second;
238 }
239
getPreviousAndNextStmt(Expr * E)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
getReferencedDecl(Expr * E)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.
checkForGCDOrXPC(ObjCMessageExpr * Msg,Expr * & RecContainer,Expr * & Rec,SourceRange & RecRange)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
clearDiagnostics(SourceLocation loc) const384 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
isDelegateMessage(Expr * E) const391 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
isInAtFinally(Expr * E) const406 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
isRemovable(Expr * E) const418 bool isRemovable(Expr *E) const {
419 return Removables.count(E);
420 }
421
tryRemoving(Expr * E) const422 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
removeRetainReleaseDeallocFinalize(MigrationPass & pass)452 void trans::removeRetainReleaseDeallocFinalize(MigrationPass &pass) {
453 BodyTransform<RetainReleaseDeallocRemover> trans(pass);
454 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
455 }
456