1 //===--- TransAutoreleasePool.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 // rewriteAutoreleasePool:
10 //
11 // Calls to NSAutoreleasePools will be rewritten as an @autorelease scope.
12 //
13 //  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
14 //  ...
15 //  [pool release];
16 // ---->
17 //  @autorelease {
18 //  ...
19 //  }
20 //
21 // An NSAutoreleasePool will not be touched if:
22 // - There is not a corresponding -release/-drain in the same scope
23 // - Not all references of the NSAutoreleasePool variable can be removed
24 // - There is a variable that is declared inside the intended @autorelease scope
25 //   which is also used outside it.
26 //
27 //===----------------------------------------------------------------------===//
28 
29 #include "Transforms.h"
30 #include "Internals.h"
31 #include "clang/AST/ASTContext.h"
32 #include "clang/Basic/SourceManager.h"
33 #include "clang/Sema/SemaDiagnostic.h"
34 #include <map>
35 
36 using namespace clang;
37 using namespace arcmt;
38 using namespace trans;
39 
40 namespace {
41 
42 class ReleaseCollector : public RecursiveASTVisitor<ReleaseCollector> {
43   Decl *Dcl;
44   SmallVectorImpl<ObjCMessageExpr *> &Releases;
45 
46 public:
ReleaseCollector(Decl * D,SmallVectorImpl<ObjCMessageExpr * > & releases)47   ReleaseCollector(Decl *D, SmallVectorImpl<ObjCMessageExpr *> &releases)
48     : Dcl(D), Releases(releases) { }
49 
VisitObjCMessageExpr(ObjCMessageExpr * E)50   bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
51     if (!E->isInstanceMessage())
52       return true;
53     if (E->getMethodFamily() != OMF_release)
54       return true;
55     Expr *instance = E->getInstanceReceiver()->IgnoreParenCasts();
56     if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(instance)) {
57       if (DE->getDecl() == Dcl)
58         Releases.push_back(E);
59     }
60     return true;
61   }
62 };
63 
64 }
65 
66 namespace {
67 
68 class AutoreleasePoolRewriter
69                          : public RecursiveASTVisitor<AutoreleasePoolRewriter> {
70 public:
AutoreleasePoolRewriter(MigrationPass & pass)71   AutoreleasePoolRewriter(MigrationPass &pass)
72     : Body(nullptr), Pass(pass) {
73     PoolII = &pass.Ctx.Idents.get("NSAutoreleasePool");
74     DrainSel = pass.Ctx.Selectors.getNullarySelector(
75                                                  &pass.Ctx.Idents.get("drain"));
76   }
77 
transformBody(Stmt * body,Decl * ParentD)78   void transformBody(Stmt *body, Decl *ParentD) {
79     Body = body;
80     TraverseStmt(body);
81   }
82 
~AutoreleasePoolRewriter()83   ~AutoreleasePoolRewriter() {
84     SmallVector<VarDecl *, 8> VarsToHandle;
85 
86     for (std::map<VarDecl *, PoolVarInfo>::iterator
87            I = PoolVars.begin(), E = PoolVars.end(); I != E; ++I) {
88       VarDecl *var = I->first;
89       PoolVarInfo &info = I->second;
90 
91       // Check that we can handle/rewrite all references of the pool.
92 
93       clearRefsIn(info.Dcl, info.Refs);
94       for (SmallVectorImpl<PoolScope>::iterator
95              scpI = info.Scopes.begin(),
96              scpE = info.Scopes.end(); scpI != scpE; ++scpI) {
97         PoolScope &scope = *scpI;
98         clearRefsIn(*scope.Begin, info.Refs);
99         clearRefsIn(*scope.End, info.Refs);
100         clearRefsIn(scope.Releases.begin(), scope.Releases.end(), info.Refs);
101       }
102 
103       // Even if one reference is not handled we will not do anything about that
104       // pool variable.
105       if (info.Refs.empty())
106         VarsToHandle.push_back(var);
107     }
108 
109     for (unsigned i = 0, e = VarsToHandle.size(); i != e; ++i) {
110       PoolVarInfo &info = PoolVars[VarsToHandle[i]];
111 
112       Transaction Trans(Pass.TA);
113 
114       clearUnavailableDiags(info.Dcl);
115       Pass.TA.removeStmt(info.Dcl);
116 
117       // Add "@autoreleasepool { }"
118       for (SmallVectorImpl<PoolScope>::iterator
119              scpI = info.Scopes.begin(),
120              scpE = info.Scopes.end(); scpI != scpE; ++scpI) {
121         PoolScope &scope = *scpI;
122         clearUnavailableDiags(*scope.Begin);
123         clearUnavailableDiags(*scope.End);
124         if (scope.IsFollowedBySimpleReturnStmt) {
125           // Include the return in the scope.
126           Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {");
127           Pass.TA.removeStmt(*scope.End);
128           Stmt::child_iterator retI = scope.End;
129           ++retI;
130           SourceLocation afterSemi =
131               findLocationAfterSemi((*retI)->getEndLoc(), Pass.Ctx);
132           assert(afterSemi.isValid() &&
133                  "Didn't we check before setting IsFollowedBySimpleReturnStmt "
134                  "to true?");
135           Pass.TA.insertAfterToken(afterSemi, "\n}");
136           Pass.TA.increaseIndentation(
137               SourceRange(scope.getIndentedRange().getBegin(),
138                           (*retI)->getEndLoc()),
139               scope.CompoundParent->getBeginLoc());
140         } else {
141           Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {");
142           Pass.TA.replaceStmt(*scope.End, "}");
143           Pass.TA.increaseIndentation(scope.getIndentedRange(),
144                                       scope.CompoundParent->getBeginLoc());
145         }
146       }
147 
148       // Remove rest of pool var references.
149       for (SmallVectorImpl<PoolScope>::iterator
150              scpI = info.Scopes.begin(),
151              scpE = info.Scopes.end(); scpI != scpE; ++scpI) {
152         PoolScope &scope = *scpI;
153         for (SmallVectorImpl<ObjCMessageExpr *>::iterator
154                relI = scope.Releases.begin(),
155                relE = scope.Releases.end(); relI != relE; ++relI) {
156           clearUnavailableDiags(*relI);
157           Pass.TA.removeStmt(*relI);
158         }
159       }
160     }
161   }
162 
VisitCompoundStmt(CompoundStmt * S)163   bool VisitCompoundStmt(CompoundStmt *S) {
164     SmallVector<PoolScope, 4> Scopes;
165 
166     for (Stmt::child_iterator
167            I = S->body_begin(), E = S->body_end(); I != E; ++I) {
168       Stmt *child = getEssential(*I);
169       if (DeclStmt *DclS = dyn_cast<DeclStmt>(child)) {
170         if (DclS->isSingleDecl()) {
171           if (VarDecl *VD = dyn_cast<VarDecl>(DclS->getSingleDecl())) {
172             if (isNSAutoreleasePool(VD->getType())) {
173               PoolVarInfo &info = PoolVars[VD];
174               info.Dcl = DclS;
175               collectRefs(VD, S, info.Refs);
176               // Does this statement follow the pattern:
177               // NSAutoreleasePool * pool = [NSAutoreleasePool  new];
178               if (isPoolCreation(VD->getInit())) {
179                 Scopes.push_back(PoolScope());
180                 Scopes.back().PoolVar = VD;
181                 Scopes.back().CompoundParent = S;
182                 Scopes.back().Begin = I;
183               }
184             }
185           }
186         }
187       } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(child)) {
188         if (DeclRefExpr *dref = dyn_cast<DeclRefExpr>(bop->getLHS())) {
189           if (VarDecl *VD = dyn_cast<VarDecl>(dref->getDecl())) {
190             // Does this statement follow the pattern:
191             // pool = [NSAutoreleasePool  new];
192             if (isNSAutoreleasePool(VD->getType()) &&
193                 isPoolCreation(bop->getRHS())) {
194               Scopes.push_back(PoolScope());
195               Scopes.back().PoolVar = VD;
196               Scopes.back().CompoundParent = S;
197               Scopes.back().Begin = I;
198             }
199           }
200         }
201       }
202 
203       if (Scopes.empty())
204         continue;
205 
206       if (isPoolDrain(Scopes.back().PoolVar, child)) {
207         PoolScope &scope = Scopes.back();
208         scope.End = I;
209         handlePoolScope(scope, S);
210         Scopes.pop_back();
211       }
212     }
213     return true;
214   }
215 
216 private:
clearUnavailableDiags(Stmt * S)217   void clearUnavailableDiags(Stmt *S) {
218     if (S)
219       Pass.TA.clearDiagnostic(diag::err_unavailable,
220                               diag::err_unavailable_message,
221                               S->getSourceRange());
222   }
223 
224   struct PoolScope {
225     VarDecl *PoolVar;
226     CompoundStmt *CompoundParent;
227     Stmt::child_iterator Begin;
228     Stmt::child_iterator End;
229     bool IsFollowedBySimpleReturnStmt;
230     SmallVector<ObjCMessageExpr *, 4> Releases;
231 
PoolScope__anon34d6ee710211::AutoreleasePoolRewriter::PoolScope232     PoolScope()
233         : PoolVar(nullptr), CompoundParent(nullptr),
234           IsFollowedBySimpleReturnStmt(false) {}
235 
getIndentedRange__anon34d6ee710211::AutoreleasePoolRewriter::PoolScope236     SourceRange getIndentedRange() const {
237       Stmt::child_iterator rangeS = Begin;
238       ++rangeS;
239       if (rangeS == End)
240         return SourceRange();
241       Stmt::child_iterator rangeE = Begin;
242       for (Stmt::child_iterator I = rangeS; I != End; ++I)
243         ++rangeE;
244       return SourceRange((*rangeS)->getBeginLoc(), (*rangeE)->getEndLoc());
245     }
246   };
247 
248   class NameReferenceChecker : public RecursiveASTVisitor<NameReferenceChecker>{
249     ASTContext &Ctx;
250     SourceRange ScopeRange;
251     SourceLocation &referenceLoc, &declarationLoc;
252 
253   public:
NameReferenceChecker(ASTContext & ctx,PoolScope & scope,SourceLocation & referenceLoc,SourceLocation & declarationLoc)254     NameReferenceChecker(ASTContext &ctx, PoolScope &scope,
255                          SourceLocation &referenceLoc,
256                          SourceLocation &declarationLoc)
257       : Ctx(ctx), referenceLoc(referenceLoc),
258         declarationLoc(declarationLoc) {
259       ScopeRange = SourceRange((*scope.Begin)->getBeginLoc(),
260                                (*scope.End)->getBeginLoc());
261     }
262 
VisitDeclRefExpr(DeclRefExpr * E)263     bool VisitDeclRefExpr(DeclRefExpr *E) {
264       return checkRef(E->getLocation(), E->getDecl()->getLocation());
265     }
266 
VisitTypedefTypeLoc(TypedefTypeLoc TL)267     bool VisitTypedefTypeLoc(TypedefTypeLoc TL) {
268       return checkRef(TL.getBeginLoc(), TL.getTypedefNameDecl()->getLocation());
269     }
270 
VisitTagTypeLoc(TagTypeLoc TL)271     bool VisitTagTypeLoc(TagTypeLoc TL) {
272       return checkRef(TL.getBeginLoc(), TL.getDecl()->getLocation());
273     }
274 
275   private:
checkRef(SourceLocation refLoc,SourceLocation declLoc)276     bool checkRef(SourceLocation refLoc, SourceLocation declLoc) {
277       if (isInScope(declLoc)) {
278         referenceLoc = refLoc;
279         declarationLoc = declLoc;
280         return false;
281       }
282       return true;
283     }
284 
isInScope(SourceLocation loc)285     bool isInScope(SourceLocation loc) {
286       if (loc.isInvalid())
287         return false;
288 
289       SourceManager &SM = Ctx.getSourceManager();
290       if (SM.isBeforeInTranslationUnit(loc, ScopeRange.getBegin()))
291         return false;
292       return SM.isBeforeInTranslationUnit(loc, ScopeRange.getEnd());
293     }
294   };
295 
handlePoolScope(PoolScope & scope,CompoundStmt * compoundS)296   void handlePoolScope(PoolScope &scope, CompoundStmt *compoundS) {
297     // Check that all names declared inside the scope are not used
298     // outside the scope.
299     {
300       bool nameUsedOutsideScope = false;
301       SourceLocation referenceLoc, declarationLoc;
302       Stmt::child_iterator SI = scope.End, SE = compoundS->body_end();
303       ++SI;
304       // Check if the autoreleasepool scope is followed by a simple return
305       // statement, in which case we will include the return in the scope.
306       if (SI != SE)
307         if (ReturnStmt *retS = dyn_cast<ReturnStmt>(*SI))
308           if ((retS->getRetValue() == nullptr ||
309                isa<DeclRefExpr>(retS->getRetValue()->IgnoreParenCasts())) &&
310               findLocationAfterSemi(retS->getEndLoc(), Pass.Ctx).isValid()) {
311             scope.IsFollowedBySimpleReturnStmt = true;
312             ++SI; // the return will be included in scope, don't check it.
313           }
314 
315       for (; SI != SE; ++SI) {
316         nameUsedOutsideScope = !NameReferenceChecker(Pass.Ctx, scope,
317                                                      referenceLoc,
318                                               declarationLoc).TraverseStmt(*SI);
319         if (nameUsedOutsideScope)
320           break;
321       }
322 
323       // If not all references were cleared it means some variables/typenames/etc
324       // declared inside the pool scope are used outside of it.
325       // We won't try to rewrite the pool.
326       if (nameUsedOutsideScope) {
327         Pass.TA.reportError("a name is referenced outside the "
328             "NSAutoreleasePool scope that it was declared in", referenceLoc);
329         Pass.TA.reportNote("name declared here", declarationLoc);
330         Pass.TA.reportNote("intended @autoreleasepool scope begins here",
331                            (*scope.Begin)->getBeginLoc());
332         Pass.TA.reportNote("intended @autoreleasepool scope ends here",
333                            (*scope.End)->getBeginLoc());
334         return;
335       }
336     }
337 
338     // Collect all releases of the pool; they will be removed.
339     {
340       ReleaseCollector releaseColl(scope.PoolVar, scope.Releases);
341       Stmt::child_iterator I = scope.Begin;
342       ++I;
343       for (; I != scope.End; ++I)
344         releaseColl.TraverseStmt(*I);
345     }
346 
347     PoolVars[scope.PoolVar].Scopes.push_back(scope);
348   }
349 
isPoolCreation(Expr * E)350   bool isPoolCreation(Expr *E) {
351     if (!E) return false;
352     E = getEssential(E);
353     ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E);
354     if (!ME) return false;
355     if (ME->getMethodFamily() == OMF_new &&
356         ME->getReceiverKind() == ObjCMessageExpr::Class &&
357         isNSAutoreleasePool(ME->getReceiverInterface()))
358       return true;
359     if (ME->getReceiverKind() == ObjCMessageExpr::Instance &&
360         ME->getMethodFamily() == OMF_init) {
361       Expr *rec = getEssential(ME->getInstanceReceiver());
362       if (ObjCMessageExpr *recME = dyn_cast_or_null<ObjCMessageExpr>(rec)) {
363         if (recME->getMethodFamily() == OMF_alloc &&
364             recME->getReceiverKind() == ObjCMessageExpr::Class &&
365             isNSAutoreleasePool(recME->getReceiverInterface()))
366           return true;
367       }
368     }
369 
370     return false;
371   }
372 
isPoolDrain(VarDecl * poolVar,Stmt * S)373   bool isPoolDrain(VarDecl *poolVar, Stmt *S) {
374     if (!S) return false;
375     S = getEssential(S);
376     ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(S);
377     if (!ME) return false;
378     if (ME->getReceiverKind() == ObjCMessageExpr::Instance) {
379       Expr *rec = getEssential(ME->getInstanceReceiver());
380       if (DeclRefExpr *dref = dyn_cast<DeclRefExpr>(rec))
381         if (dref->getDecl() == poolVar)
382           return ME->getMethodFamily() == OMF_release ||
383                  ME->getSelector() == DrainSel;
384     }
385 
386     return false;
387   }
388 
isNSAutoreleasePool(ObjCInterfaceDecl * IDecl)389   bool isNSAutoreleasePool(ObjCInterfaceDecl *IDecl) {
390     return IDecl && IDecl->getIdentifier() == PoolII;
391   }
392 
isNSAutoreleasePool(QualType Ty)393   bool isNSAutoreleasePool(QualType Ty) {
394     QualType pointee = Ty->getPointeeType();
395     if (pointee.isNull())
396       return false;
397     if (const ObjCInterfaceType *interT = pointee->getAs<ObjCInterfaceType>())
398       return isNSAutoreleasePool(interT->getDecl());
399     return false;
400   }
401 
getEssential(Expr * E)402   static Expr *getEssential(Expr *E) {
403     return cast<Expr>(getEssential((Stmt*)E));
404   }
getEssential(Stmt * S)405   static Stmt *getEssential(Stmt *S) {
406     if (FullExpr *FE = dyn_cast<FullExpr>(S))
407       S = FE->getSubExpr();
408     if (Expr *E = dyn_cast<Expr>(S))
409       S = E->IgnoreParenCasts();
410     return S;
411   }
412 
413   Stmt *Body;
414   MigrationPass &Pass;
415 
416   IdentifierInfo *PoolII;
417   Selector DrainSel;
418 
419   struct PoolVarInfo {
420     DeclStmt *Dcl;
421     ExprSet Refs;
422     SmallVector<PoolScope, 2> Scopes;
423 
PoolVarInfo__anon34d6ee710211::AutoreleasePoolRewriter::PoolVarInfo424     PoolVarInfo() : Dcl(nullptr) { }
425   };
426 
427   std::map<VarDecl *, PoolVarInfo> PoolVars;
428 };
429 
430 } // anonymous namespace
431 
rewriteAutoreleasePool(MigrationPass & pass)432 void trans::rewriteAutoreleasePool(MigrationPass &pass) {
433   BodyTransform<AutoreleasePoolRewriter> trans(pass);
434   trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
435 }
436