1 //===--- TransRetainReleaseDealloc.cpp - Tranformations 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/Sema/SemaDiagnostic.h"
23 #include "clang/AST/ParentMap.h"
24 #include "clang/Lex/Lexer.h"
25 #include "clang/Basic/SourceManager.h"
26
27 using namespace clang;
28 using namespace arcmt;
29 using namespace trans;
30
31 namespace {
32
33 class RetainReleaseDeallocRemover :
34 public RecursiveASTVisitor<RetainReleaseDeallocRemover> {
35 Stmt *Body;
36 MigrationPass &Pass;
37
38 ExprSet Removables;
39 OwningPtr<ParentMap> StmtMap;
40
41 Selector DelegateSel, FinalizeSel;
42
43 public:
RetainReleaseDeallocRemover(MigrationPass & pass)44 RetainReleaseDeallocRemover(MigrationPass &pass)
45 : Body(0), Pass(pass) {
46 DelegateSel =
47 Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("delegate"));
48 FinalizeSel =
49 Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
50 }
51
transformBody(Stmt * body)52 void transformBody(Stmt *body) {
53 Body = body;
54 collectRemovables(body, Removables);
55 StmtMap.reset(new ParentMap(body));
56 TraverseStmt(body);
57 }
58
VisitObjCMessageExpr(ObjCMessageExpr * E)59 bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
60 switch (E->getMethodFamily()) {
61 default:
62 if (E->isInstanceMessage() && E->getSelector() == FinalizeSel)
63 break;
64 return true;
65 case OMF_autorelease:
66 if (isRemovable(E)) {
67 // An unused autorelease is badness. If we remove it the receiver
68 // will likely die immediately while previously it was kept alive
69 // by the autorelease pool. This is bad practice in general, leave it
70 // and emit an error to force the user to restructure his code.
71 Pass.TA.reportError("it is not safe to remove an unused 'autorelease' "
72 "message; its receiver may be destroyed immediately",
73 E->getLocStart(), E->getSourceRange());
74 return true;
75 }
76 // Pass through.
77 case OMF_retain:
78 case OMF_release:
79 if (E->getReceiverKind() == ObjCMessageExpr::Instance)
80 if (Expr *rec = E->getInstanceReceiver()) {
81 rec = rec->IgnoreParenImpCasts();
82 if (rec->getType().getObjCLifetime() == Qualifiers::OCL_ExplicitNone &&
83 (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
84 std::string err = "it is not safe to remove '";
85 err += E->getSelector().getAsString() + "' message on "
86 "an __unsafe_unretained type";
87 Pass.TA.reportError(err, rec->getLocStart());
88 return true;
89 }
90
91 if (isGlobalVar(rec) &&
92 (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
93 std::string err = "it is not safe to remove '";
94 err += E->getSelector().getAsString() + "' message on "
95 "a global variable";
96 Pass.TA.reportError(err, rec->getLocStart());
97 return true;
98 }
99
100 if (E->getMethodFamily() == OMF_release && isDelegateMessage(rec)) {
101 Pass.TA.reportError("it is not safe to remove 'retain' "
102 "message on the result of a 'delegate' message; "
103 "the object that was passed to 'setDelegate:' may not be "
104 "properly retained", rec->getLocStart());
105 return true;
106 }
107 }
108 case OMF_dealloc:
109 break;
110 }
111
112 switch (E->getReceiverKind()) {
113 default:
114 return true;
115 case ObjCMessageExpr::SuperInstance: {
116 Transaction Trans(Pass.TA);
117 clearDiagnostics(E->getSuperLoc());
118 if (tryRemoving(E))
119 return true;
120 Pass.TA.replace(E->getSourceRange(), "self");
121 return true;
122 }
123 case ObjCMessageExpr::Instance:
124 break;
125 }
126
127 Expr *rec = E->getInstanceReceiver();
128 if (!rec) return true;
129
130 Transaction Trans(Pass.TA);
131 clearDiagnostics(rec->getExprLoc());
132
133 ObjCMessageExpr *Msg = E;
134 Expr *RecContainer = Msg;
135 SourceRange RecRange = rec->getSourceRange();
136 checkForGCDOrXPC(Msg, RecContainer, rec, RecRange);
137
138 if (Msg->getMethodFamily() == OMF_release &&
139 isRemovable(RecContainer) && isInAtFinally(RecContainer)) {
140 // Change the -release to "receiver = nil" in a finally to avoid a leak
141 // when an exception is thrown.
142 Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
143 std::string str = " = ";
144 str += getNilString(Pass.Ctx);
145 Pass.TA.insertAfterToken(RecRange.getEnd(), str);
146 return true;
147 }
148
149 if (!hasSideEffects(rec, Pass.Ctx)) {
150 if (tryRemoving(RecContainer))
151 return true;
152 }
153 Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
154
155 return true;
156 }
157
158 private:
159 /// \brief Check if the retain/release is due to a GCD/XPC macro that are
160 /// defined as:
161 ///
162 /// #define dispatch_retain(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); (void)[_o retain]; })
163 /// #define dispatch_release(object) ({ dispatch_object_t _o = (object); _dispatch_object_validate(_o); [_o release]; })
164 /// #define xpc_retain(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o retain]; })
165 /// #define xpc_release(object) ({ xpc_object_t _o = (object); _xpc_object_validate(_o); [_o release]; })
166 ///
167 /// and return the top container which is the StmtExpr and the macro argument
168 /// expression.
checkForGCDOrXPC(ObjCMessageExpr * Msg,Expr * & RecContainer,Expr * & Rec,SourceRange & RecRange)169 void checkForGCDOrXPC(ObjCMessageExpr *Msg, Expr *&RecContainer,
170 Expr *&Rec, SourceRange &RecRange) {
171 SourceLocation Loc = Msg->getExprLoc();
172 if (!Loc.isMacroID())
173 return;
174 SourceManager &SM = Pass.Ctx.getSourceManager();
175 StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM,
176 Pass.Ctx.getLangOpts());
177 bool isGCDOrXPC = llvm::StringSwitch<bool>(MacroName)
178 .Case("dispatch_retain", true)
179 .Case("dispatch_release", true)
180 .Case("xpc_retain", true)
181 .Case("xpc_release", true)
182 .Default(false);
183 if (!isGCDOrXPC)
184 return;
185
186 StmtExpr *StmtE = 0;
187 Stmt *S = Msg;
188 while (S) {
189 if (StmtExpr *SE = dyn_cast<StmtExpr>(S)) {
190 StmtE = SE;
191 break;
192 }
193 S = StmtMap->getParent(S);
194 }
195
196 if (!StmtE)
197 return;
198
199 Stmt::child_range StmtExprChild = StmtE->children();
200 if (!StmtExprChild)
201 return;
202 CompoundStmt *CompS = dyn_cast_or_null<CompoundStmt>(*StmtExprChild);
203 if (!CompS)
204 return;
205
206 Stmt::child_range CompStmtChild = CompS->children();
207 if (!CompStmtChild)
208 return;
209 DeclStmt *DeclS = dyn_cast_or_null<DeclStmt>(*CompStmtChild);
210 if (!DeclS)
211 return;
212 if (!DeclS->isSingleDecl())
213 return;
214 VarDecl *VD = dyn_cast_or_null<VarDecl>(DeclS->getSingleDecl());
215 if (!VD)
216 return;
217 Expr *Init = VD->getInit();
218 if (!Init)
219 return;
220
221 RecContainer = StmtE;
222 Rec = Init->IgnoreParenImpCasts();
223 if (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(Rec))
224 Rec = EWC->getSubExpr()->IgnoreParenImpCasts();
225 RecRange = Rec->getSourceRange();
226 if (SM.isMacroArgExpansion(RecRange.getBegin()))
227 RecRange.setBegin(SM.getImmediateSpellingLoc(RecRange.getBegin()));
228 if (SM.isMacroArgExpansion(RecRange.getEnd()))
229 RecRange.setEnd(SM.getImmediateSpellingLoc(RecRange.getEnd()));
230 }
231
clearDiagnostics(SourceLocation loc) const232 void clearDiagnostics(SourceLocation loc) const {
233 Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message,
234 diag::err_unavailable,
235 diag::err_unavailable_message,
236 loc);
237 }
238
isDelegateMessage(Expr * E) const239 bool isDelegateMessage(Expr *E) const {
240 if (!E) return false;
241
242 E = E->IgnoreParenCasts();
243
244 // Also look through property-getter sugar.
245 if (PseudoObjectExpr *pseudoOp = dyn_cast<PseudoObjectExpr>(E))
246 E = pseudoOp->getResultExpr()->IgnoreImplicit();
247
248 if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
249 return (ME->isInstanceMessage() && ME->getSelector() == DelegateSel);
250
251 return false;
252 }
253
isInAtFinally(Expr * E) const254 bool isInAtFinally(Expr *E) const {
255 assert(E);
256 Stmt *S = E;
257 while (S) {
258 if (isa<ObjCAtFinallyStmt>(S))
259 return true;
260 S = StmtMap->getParent(S);
261 }
262
263 return false;
264 }
265
isRemovable(Expr * E) const266 bool isRemovable(Expr *E) const {
267 return Removables.count(E);
268 }
269
tryRemoving(Expr * E) const270 bool tryRemoving(Expr *E) const {
271 if (isRemovable(E)) {
272 Pass.TA.removeStmt(E);
273 return true;
274 }
275
276 Stmt *parent = StmtMap->getParent(E);
277
278 if (ImplicitCastExpr *castE = dyn_cast_or_null<ImplicitCastExpr>(parent))
279 return tryRemoving(castE);
280
281 if (ParenExpr *parenE = dyn_cast_or_null<ParenExpr>(parent))
282 return tryRemoving(parenE);
283
284 if (BinaryOperator *
285 bopE = dyn_cast_or_null<BinaryOperator>(parent)) {
286 if (bopE->getOpcode() == BO_Comma && bopE->getLHS() == E &&
287 isRemovable(bopE)) {
288 Pass.TA.replace(bopE->getSourceRange(), bopE->getRHS()->getSourceRange());
289 return true;
290 }
291 }
292
293 return false;
294 }
295
296 };
297
298 } // anonymous namespace
299
removeRetainReleaseDeallocFinalize(MigrationPass & pass)300 void trans::removeRetainReleaseDeallocFinalize(MigrationPass &pass) {
301 BodyTransform<RetainReleaseDeallocRemover> trans(pass);
302 trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
303 }
304