|
150
|
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
|
|
|
28 using namespace clang;
|
|
|
29 using namespace arcmt;
|
|
|
30 using namespace trans;
|
|
|
31
|
|
|
32 namespace {
|
|
|
33
|
|
|
34 class 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
|
|
|
44 public:
|
|
|
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 LLVM_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
|
|
|
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<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
|
|
|
456 void trans::removeRetainReleaseDeallocFinalize(MigrationPass &pass) {
|
|
|
457 BodyTransform<RetainReleaseDeallocRemover> trans(pass);
|
|
|
458 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
459 }
|
