• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--- TransAutoreleasePool.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 // rewriteAutoreleasePool:
11 //
12 // Calls to NSAutoreleasePools will be rewritten as an @autorelease scope.
13 //
14 //  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
15 //  ...
16 //  [pool release];
17 // ---->
18 //  @autorelease {
19 //  ...
20 //  }
21 //
22 // An NSAutoreleasePool will not be touched if:
23 // - There is not a corresponding -release/-drain in the same scope
24 // - Not all references of the NSAutoreleasePool variable can be removed
25 // - There is a variable that is declared inside the intended @autorelease scope
26 //   which is also used outside it.
27 //
28 //===----------------------------------------------------------------------===//
29 
30 #include "Transforms.h"
31 #include "Internals.h"
32 #include "clang/AST/ASTContext.h"
33 #include "clang/Basic/SourceManager.h"
34 #include "clang/Sema/SemaDiagnostic.h"
35 #include <map>
36 
37 using namespace clang;
38 using namespace arcmt;
39 using namespace trans;
40 
41 namespace {
42 
43 class ReleaseCollector : public RecursiveASTVisitor<ReleaseCollector> {
44   Decl *Dcl;
45   SmallVectorImpl<ObjCMessageExpr *> &Releases;
46 
47 public:
ReleaseCollector(Decl * D,SmallVectorImpl<ObjCMessageExpr * > & releases)48   ReleaseCollector(Decl *D, SmallVectorImpl<ObjCMessageExpr *> &releases)
49     : Dcl(D), Releases(releases) { }
50 
VisitObjCMessageExpr(ObjCMessageExpr * E)51   bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
52     if (!E->isInstanceMessage())
53       return true;
54     if (E->getMethodFamily() != OMF_release)
55       return true;
56     Expr *instance = E->getInstanceReceiver()->IgnoreParenCasts();
57     if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(instance)) {
58       if (DE->getDecl() == Dcl)
59         Releases.push_back(E);
60     }
61     return true;
62   }
63 };
64 
65 }
66 
67 namespace {
68 
69 class AutoreleasePoolRewriter
70                          : public RecursiveASTVisitor<AutoreleasePoolRewriter> {
71 public:
AutoreleasePoolRewriter(MigrationPass & pass)72   AutoreleasePoolRewriter(MigrationPass &pass)
73     : Body(nullptr), Pass(pass) {
74     PoolII = &pass.Ctx.Idents.get("NSAutoreleasePool");
75     DrainSel = pass.Ctx.Selectors.getNullarySelector(
76                                                  &pass.Ctx.Idents.get("drain"));
77   }
78 
transformBody(Stmt * body,Decl * ParentD)79   void transformBody(Stmt *body, Decl *ParentD) {
80     Body = body;
81     TraverseStmt(body);
82   }
83 
~AutoreleasePoolRewriter()84   ~AutoreleasePoolRewriter() {
85     SmallVector<VarDecl *, 8> VarsToHandle;
86 
87     for (std::map<VarDecl *, PoolVarInfo>::iterator
88            I = PoolVars.begin(), E = PoolVars.end(); I != E; ++I) {
89       VarDecl *var = I->first;
90       PoolVarInfo &info = I->second;
91 
92       // Check that we can handle/rewrite all references of the pool.
93 
94       clearRefsIn(info.Dcl, info.Refs);
95       for (SmallVectorImpl<PoolScope>::iterator
96              scpI = info.Scopes.begin(),
97              scpE = info.Scopes.end(); scpI != scpE; ++scpI) {
98         PoolScope &scope = *scpI;
99         clearRefsIn(*scope.Begin, info.Refs);
100         clearRefsIn(*scope.End, info.Refs);
101         clearRefsIn(scope.Releases.begin(), scope.Releases.end(), info.Refs);
102       }
103 
104       // Even if one reference is not handled we will not do anything about that
105       // pool variable.
106       if (info.Refs.empty())
107         VarsToHandle.push_back(var);
108     }
109 
110     for (unsigned i = 0, e = VarsToHandle.size(); i != e; ++i) {
111       PoolVarInfo &info = PoolVars[VarsToHandle[i]];
112 
113       Transaction Trans(Pass.TA);
114 
115       clearUnavailableDiags(info.Dcl);
116       Pass.TA.removeStmt(info.Dcl);
117 
118       // Add "@autoreleasepool { }"
119       for (SmallVectorImpl<PoolScope>::iterator
120              scpI = info.Scopes.begin(),
121              scpE = info.Scopes.end(); scpI != scpE; ++scpI) {
122         PoolScope &scope = *scpI;
123         clearUnavailableDiags(*scope.Begin);
124         clearUnavailableDiags(*scope.End);
125         if (scope.IsFollowedBySimpleReturnStmt) {
126           // Include the return in the scope.
127           Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {");
128           Pass.TA.removeStmt(*scope.End);
129           Stmt::child_iterator retI = scope.End;
130           ++retI;
131           SourceLocation afterSemi = findLocationAfterSemi((*retI)->getLocEnd(),
132                                                            Pass.Ctx);
133           assert(afterSemi.isValid() &&
134                  "Didn't we check before setting IsFollowedBySimpleReturnStmt "
135                  "to true?");
136           Pass.TA.insertAfterToken(afterSemi, "\n}");
137           Pass.TA.increaseIndentation(
138                                 SourceRange(scope.getIndentedRange().getBegin(),
139                                             (*retI)->getLocEnd()),
140                                       scope.CompoundParent->getLocStart());
141         } else {
142           Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {");
143           Pass.TA.replaceStmt(*scope.End, "}");
144           Pass.TA.increaseIndentation(scope.getIndentedRange(),
145                                       scope.CompoundParent->getLocStart());
146         }
147       }
148 
149       // Remove rest of pool var references.
150       for (SmallVectorImpl<PoolScope>::iterator
151              scpI = info.Scopes.begin(),
152              scpE = info.Scopes.end(); scpI != scpE; ++scpI) {
153         PoolScope &scope = *scpI;
154         for (SmallVectorImpl<ObjCMessageExpr *>::iterator
155                relI = scope.Releases.begin(),
156                relE = scope.Releases.end(); relI != relE; ++relI) {
157           clearUnavailableDiags(*relI);
158           Pass.TA.removeStmt(*relI);
159         }
160       }
161     }
162   }
163 
VisitCompoundStmt(CompoundStmt * S)164   bool VisitCompoundStmt(CompoundStmt *S) {
165     SmallVector<PoolScope, 4> Scopes;
166 
167     for (Stmt::child_iterator
168            I = S->body_begin(), E = S->body_end(); I != E; ++I) {
169       Stmt *child = getEssential(*I);
170       if (DeclStmt *DclS = dyn_cast<DeclStmt>(child)) {
171         if (DclS->isSingleDecl()) {
172           if (VarDecl *VD = dyn_cast<VarDecl>(DclS->getSingleDecl())) {
173             if (isNSAutoreleasePool(VD->getType())) {
174               PoolVarInfo &info = PoolVars[VD];
175               info.Dcl = DclS;
176               collectRefs(VD, S, info.Refs);
177               // Does this statement follow the pattern:
178               // NSAutoreleasePool * pool = [NSAutoreleasePool  new];
179               if (isPoolCreation(VD->getInit())) {
180                 Scopes.push_back(PoolScope());
181                 Scopes.back().PoolVar = VD;
182                 Scopes.back().CompoundParent = S;
183                 Scopes.back().Begin = I;
184               }
185             }
186           }
187         }
188       } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(child)) {
189         if (DeclRefExpr *dref = dyn_cast<DeclRefExpr>(bop->getLHS())) {
190           if (VarDecl *VD = dyn_cast<VarDecl>(dref->getDecl())) {
191             // Does this statement follow the pattern:
192             // pool = [NSAutoreleasePool  new];
193             if (isNSAutoreleasePool(VD->getType()) &&
194                 isPoolCreation(bop->getRHS())) {
195               Scopes.push_back(PoolScope());
196               Scopes.back().PoolVar = VD;
197               Scopes.back().CompoundParent = S;
198               Scopes.back().Begin = I;
199             }
200           }
201         }
202       }
203 
204       if (Scopes.empty())
205         continue;
206 
207       if (isPoolDrain(Scopes.back().PoolVar, child)) {
208         PoolScope &scope = Scopes.back();
209         scope.End = I;
210         handlePoolScope(scope, S);
211         Scopes.pop_back();
212       }
213     }
214     return true;
215   }
216 
217 private:
clearUnavailableDiags(Stmt * S)218   void clearUnavailableDiags(Stmt *S) {
219     if (S)
220       Pass.TA.clearDiagnostic(diag::err_unavailable,
221                               diag::err_unavailable_message,
222                               S->getSourceRange());
223   }
224 
225   struct PoolScope {
226     VarDecl *PoolVar;
227     CompoundStmt *CompoundParent;
228     Stmt::child_iterator Begin;
229     Stmt::child_iterator End;
230     bool IsFollowedBySimpleReturnStmt;
231     SmallVector<ObjCMessageExpr *, 4> Releases;
232 
PoolScope__anon37f5eb850211::AutoreleasePoolRewriter::PoolScope233     PoolScope() : PoolVar(nullptr), CompoundParent(nullptr), Begin(), End(),
234                   IsFollowedBySimpleReturnStmt(false) { }
235 
getIndentedRange__anon37f5eb850211::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)->getLocStart(), (*rangeE)->getLocEnd());
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)->getLocStart(),
260                                (*scope.End)->getLocStart());
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->getLocEnd(), 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)->getLocStart());
332         Pass.TA.reportNote("intended @autoreleasepool scope ends here",
333                            (*scope.End)->getLocStart());
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 (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(S))
407       S = EWC->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__anon37f5eb850211::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