| //===--- TransAutoreleasePool.cpp - Transformations to ARC mode -----------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // rewriteAutoreleasePool: |
| // |
| // Calls to NSAutoreleasePools will be rewritten as an @autorelease scope. |
| // |
| // NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
| // ... |
| // [pool release]; |
| // ----> |
| // @autorelease { |
| // ... |
| // } |
| // |
| // An NSAutoreleasePool will not be touched if: |
| // - There is not a corresponding -release/-drain in the same scope |
| // - Not all references of the NSAutoreleasePool variable can be removed |
| // - There is a variable that is declared inside the intended @autorelease scope |
| // which is also used outside it. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "Transforms.h" |
| #include "Internals.h" |
| #include "clang/AST/ASTContext.h" |
| #include "clang/Basic/SourceManager.h" |
| #include "clang/Sema/SemaDiagnostic.h" |
| #include <map> |
| |
| using namespace clang; |
| using namespace arcmt; |
| using namespace trans; |
| |
| namespace { |
| |
| class ReleaseCollector : public RecursiveASTVisitor<ReleaseCollector> { |
| Decl *Dcl; |
| SmallVectorImpl<ObjCMessageExpr *> &Releases; |
| |
| public: |
| ReleaseCollector(Decl *D, SmallVectorImpl<ObjCMessageExpr *> &releases) |
| : Dcl(D), Releases(releases) { } |
| |
| bool VisitObjCMessageExpr(ObjCMessageExpr *E) { |
| if (!E->isInstanceMessage()) |
| return true; |
| if (E->getMethodFamily() != OMF_release) |
| return true; |
| Expr *instance = E->getInstanceReceiver()->IgnoreParenCasts(); |
| if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(instance)) { |
| if (DE->getDecl() == Dcl) |
| Releases.push_back(E); |
| } |
| return true; |
| } |
| }; |
| |
| } |
| |
| namespace { |
| |
| class AutoreleasePoolRewriter |
| : public RecursiveASTVisitor<AutoreleasePoolRewriter> { |
| public: |
| AutoreleasePoolRewriter(MigrationPass &pass) |
| : Body(0), Pass(pass) { |
| PoolII = &pass.Ctx.Idents.get("NSAutoreleasePool"); |
| DrainSel = pass.Ctx.Selectors.getNullarySelector( |
| &pass.Ctx.Idents.get("drain")); |
| } |
| |
| void transformBody(Stmt *body, Decl *ParentD) { |
| Body = body; |
| TraverseStmt(body); |
| } |
| |
| ~AutoreleasePoolRewriter() { |
| SmallVector<VarDecl *, 8> VarsToHandle; |
| |
| for (std::map<VarDecl *, PoolVarInfo>::iterator |
| I = PoolVars.begin(), E = PoolVars.end(); I != E; ++I) { |
| VarDecl *var = I->first; |
| PoolVarInfo &info = I->second; |
| |
| // Check that we can handle/rewrite all references of the pool. |
| |
| clearRefsIn(info.Dcl, info.Refs); |
| for (SmallVectorImpl<PoolScope>::iterator |
| scpI = info.Scopes.begin(), |
| scpE = info.Scopes.end(); scpI != scpE; ++scpI) { |
| PoolScope &scope = *scpI; |
| clearRefsIn(*scope.Begin, info.Refs); |
| clearRefsIn(*scope.End, info.Refs); |
| clearRefsIn(scope.Releases.begin(), scope.Releases.end(), info.Refs); |
| } |
| |
| // Even if one reference is not handled we will not do anything about that |
| // pool variable. |
| if (info.Refs.empty()) |
| VarsToHandle.push_back(var); |
| } |
| |
| for (unsigned i = 0, e = VarsToHandle.size(); i != e; ++i) { |
| PoolVarInfo &info = PoolVars[VarsToHandle[i]]; |
| |
| Transaction Trans(Pass.TA); |
| |
| clearUnavailableDiags(info.Dcl); |
| Pass.TA.removeStmt(info.Dcl); |
| |
| // Add "@autoreleasepool { }" |
| for (SmallVectorImpl<PoolScope>::iterator |
| scpI = info.Scopes.begin(), |
| scpE = info.Scopes.end(); scpI != scpE; ++scpI) { |
| PoolScope &scope = *scpI; |
| clearUnavailableDiags(*scope.Begin); |
| clearUnavailableDiags(*scope.End); |
| if (scope.IsFollowedBySimpleReturnStmt) { |
| // Include the return in the scope. |
| Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {"); |
| Pass.TA.removeStmt(*scope.End); |
| Stmt::child_iterator retI = scope.End; |
| ++retI; |
| SourceLocation afterSemi = findLocationAfterSemi((*retI)->getLocEnd(), |
| Pass.Ctx); |
| assert(afterSemi.isValid() && |
| "Didn't we check before setting IsFollowedBySimpleReturnStmt " |
| "to true?"); |
| Pass.TA.insertAfterToken(afterSemi, "\n}"); |
| Pass.TA.increaseIndentation( |
| SourceRange(scope.getIndentedRange().getBegin(), |
| (*retI)->getLocEnd()), |
| scope.CompoundParent->getLocStart()); |
| } else { |
| Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {"); |
| Pass.TA.replaceStmt(*scope.End, "}"); |
| Pass.TA.increaseIndentation(scope.getIndentedRange(), |
| scope.CompoundParent->getLocStart()); |
| } |
| } |
| |
| // Remove rest of pool var references. |
| for (SmallVectorImpl<PoolScope>::iterator |
| scpI = info.Scopes.begin(), |
| scpE = info.Scopes.end(); scpI != scpE; ++scpI) { |
| PoolScope &scope = *scpI; |
| for (SmallVectorImpl<ObjCMessageExpr *>::iterator |
| relI = scope.Releases.begin(), |
| relE = scope.Releases.end(); relI != relE; ++relI) { |
| clearUnavailableDiags(*relI); |
| Pass.TA.removeStmt(*relI); |
| } |
| } |
| } |
| } |
| |
| bool VisitCompoundStmt(CompoundStmt *S) { |
| SmallVector<PoolScope, 4> Scopes; |
| |
| for (Stmt::child_iterator |
| I = S->body_begin(), E = S->body_end(); I != E; ++I) { |
| Stmt *child = getEssential(*I); |
| if (DeclStmt *DclS = dyn_cast<DeclStmt>(child)) { |
| if (DclS->isSingleDecl()) { |
| if (VarDecl *VD = dyn_cast<VarDecl>(DclS->getSingleDecl())) { |
| if (isNSAutoreleasePool(VD->getType())) { |
| PoolVarInfo &info = PoolVars[VD]; |
| info.Dcl = DclS; |
| collectRefs(VD, S, info.Refs); |
| // Does this statement follow the pattern: |
| // NSAutoreleasePool * pool = [NSAutoreleasePool new]; |
| if (isPoolCreation(VD->getInit())) { |
| Scopes.push_back(PoolScope()); |
| Scopes.back().PoolVar = VD; |
| Scopes.back().CompoundParent = S; |
| Scopes.back().Begin = I; |
| } |
| } |
| } |
| } |
| } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(child)) { |
| if (DeclRefExpr *dref = dyn_cast<DeclRefExpr>(bop->getLHS())) { |
| if (VarDecl *VD = dyn_cast<VarDecl>(dref->getDecl())) { |
| // Does this statement follow the pattern: |
| // pool = [NSAutoreleasePool new]; |
| if (isNSAutoreleasePool(VD->getType()) && |
| isPoolCreation(bop->getRHS())) { |
| Scopes.push_back(PoolScope()); |
| Scopes.back().PoolVar = VD; |
| Scopes.back().CompoundParent = S; |
| Scopes.back().Begin = I; |
| } |
| } |
| } |
| } |
| |
| if (Scopes.empty()) |
| continue; |
| |
| if (isPoolDrain(Scopes.back().PoolVar, child)) { |
| PoolScope &scope = Scopes.back(); |
| scope.End = I; |
| handlePoolScope(scope, S); |
| Scopes.pop_back(); |
| } |
| } |
| return true; |
| } |
| |
| private: |
| void clearUnavailableDiags(Stmt *S) { |
| if (S) |
| Pass.TA.clearDiagnostic(diag::err_unavailable, |
| diag::err_unavailable_message, |
| S->getSourceRange()); |
| } |
| |
| struct PoolScope { |
| VarDecl *PoolVar; |
| CompoundStmt *CompoundParent; |
| Stmt::child_iterator Begin; |
| Stmt::child_iterator End; |
| bool IsFollowedBySimpleReturnStmt; |
| SmallVector<ObjCMessageExpr *, 4> Releases; |
| |
| PoolScope() : PoolVar(0), CompoundParent(0), Begin(), End(), |
| IsFollowedBySimpleReturnStmt(false) { } |
| |
| SourceRange getIndentedRange() const { |
| Stmt::child_iterator rangeS = Begin; |
| ++rangeS; |
| if (rangeS == End) |
| return SourceRange(); |
| Stmt::child_iterator rangeE = Begin; |
| for (Stmt::child_iterator I = rangeS; I != End; ++I) |
| ++rangeE; |
| return SourceRange((*rangeS)->getLocStart(), (*rangeE)->getLocEnd()); |
| } |
| }; |
| |
| class NameReferenceChecker : public RecursiveASTVisitor<NameReferenceChecker>{ |
| ASTContext &Ctx; |
| SourceRange ScopeRange; |
| SourceLocation &referenceLoc, &declarationLoc; |
| |
| public: |
| NameReferenceChecker(ASTContext &ctx, PoolScope &scope, |
| SourceLocation &referenceLoc, |
| SourceLocation &declarationLoc) |
| : Ctx(ctx), referenceLoc(referenceLoc), |
| declarationLoc(declarationLoc) { |
| ScopeRange = SourceRange((*scope.Begin)->getLocStart(), |
| (*scope.End)->getLocStart()); |
| } |
| |
| bool VisitDeclRefExpr(DeclRefExpr *E) { |
| return checkRef(E->getLocation(), E->getDecl()->getLocation()); |
| } |
| |
| bool VisitTypedefTypeLoc(TypedefTypeLoc TL) { |
| return checkRef(TL.getBeginLoc(), TL.getTypedefNameDecl()->getLocation()); |
| } |
| |
| bool VisitTagTypeLoc(TagTypeLoc TL) { |
| return checkRef(TL.getBeginLoc(), TL.getDecl()->getLocation()); |
| } |
| |
| private: |
| bool checkRef(SourceLocation refLoc, SourceLocation declLoc) { |
| if (isInScope(declLoc)) { |
| referenceLoc = refLoc; |
| declarationLoc = declLoc; |
| return false; |
| } |
| return true; |
| } |
| |
| bool isInScope(SourceLocation loc) { |
| if (loc.isInvalid()) |
| return false; |
| |
| SourceManager &SM = Ctx.getSourceManager(); |
| if (SM.isBeforeInTranslationUnit(loc, ScopeRange.getBegin())) |
| return false; |
| return SM.isBeforeInTranslationUnit(loc, ScopeRange.getEnd()); |
| } |
| }; |
| |
| void handlePoolScope(PoolScope &scope, CompoundStmt *compoundS) { |
| // Check that all names declared inside the scope are not used |
| // outside the scope. |
| { |
| bool nameUsedOutsideScope = false; |
| SourceLocation referenceLoc, declarationLoc; |
| Stmt::child_iterator SI = scope.End, SE = compoundS->body_end(); |
| ++SI; |
| // Check if the autoreleasepool scope is followed by a simple return |
| // statement, in which case we will include the return in the scope. |
| if (SI != SE) |
| if (ReturnStmt *retS = dyn_cast<ReturnStmt>(*SI)) |
| if ((retS->getRetValue() == 0 || |
| isa<DeclRefExpr>(retS->getRetValue()->IgnoreParenCasts())) && |
| findLocationAfterSemi(retS->getLocEnd(), Pass.Ctx).isValid()) { |
| scope.IsFollowedBySimpleReturnStmt = true; |
| ++SI; // the return will be included in scope, don't check it. |
| } |
| |
| for (; SI != SE; ++SI) { |
| nameUsedOutsideScope = !NameReferenceChecker(Pass.Ctx, scope, |
| referenceLoc, |
| declarationLoc).TraverseStmt(*SI); |
| if (nameUsedOutsideScope) |
| break; |
| } |
| |
| // If not all references were cleared it means some variables/typenames/etc |
| // declared inside the pool scope are used outside of it. |
| // We won't try to rewrite the pool. |
| if (nameUsedOutsideScope) { |
| Pass.TA.reportError("a name is referenced outside the " |
| "NSAutoreleasePool scope that it was declared in", referenceLoc); |
| Pass.TA.reportNote("name declared here", declarationLoc); |
| Pass.TA.reportNote("intended @autoreleasepool scope begins here", |
| (*scope.Begin)->getLocStart()); |
| Pass.TA.reportNote("intended @autoreleasepool scope ends here", |
| (*scope.End)->getLocStart()); |
| return; |
| } |
| } |
| |
| // Collect all releases of the pool; they will be removed. |
| { |
| ReleaseCollector releaseColl(scope.PoolVar, scope.Releases); |
| Stmt::child_iterator I = scope.Begin; |
| ++I; |
| for (; I != scope.End; ++I) |
| releaseColl.TraverseStmt(*I); |
| } |
| |
| PoolVars[scope.PoolVar].Scopes.push_back(scope); |
| } |
| |
| bool isPoolCreation(Expr *E) { |
| if (!E) return false; |
| E = getEssential(E); |
| ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E); |
| if (!ME) return false; |
| if (ME->getMethodFamily() == OMF_new && |
| ME->getReceiverKind() == ObjCMessageExpr::Class && |
| isNSAutoreleasePool(ME->getReceiverInterface())) |
| return true; |
| if (ME->getReceiverKind() == ObjCMessageExpr::Instance && |
| ME->getMethodFamily() == OMF_init) { |
| Expr *rec = getEssential(ME->getInstanceReceiver()); |
| if (ObjCMessageExpr *recME = dyn_cast_or_null<ObjCMessageExpr>(rec)) { |
| if (recME->getMethodFamily() == OMF_alloc && |
| recME->getReceiverKind() == ObjCMessageExpr::Class && |
| isNSAutoreleasePool(recME->getReceiverInterface())) |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| bool isPoolDrain(VarDecl *poolVar, Stmt *S) { |
| if (!S) return false; |
| S = getEssential(S); |
| ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(S); |
| if (!ME) return false; |
| if (ME->getReceiverKind() == ObjCMessageExpr::Instance) { |
| Expr *rec = getEssential(ME->getInstanceReceiver()); |
| if (DeclRefExpr *dref = dyn_cast<DeclRefExpr>(rec)) |
| if (dref->getDecl() == poolVar) |
| return ME->getMethodFamily() == OMF_release || |
| ME->getSelector() == DrainSel; |
| } |
| |
| return false; |
| } |
| |
| bool isNSAutoreleasePool(ObjCInterfaceDecl *IDecl) { |
| return IDecl && IDecl->getIdentifier() == PoolII; |
| } |
| |
| bool isNSAutoreleasePool(QualType Ty) { |
| QualType pointee = Ty->getPointeeType(); |
| if (pointee.isNull()) |
| return false; |
| if (const ObjCInterfaceType *interT = pointee->getAs<ObjCInterfaceType>()) |
| return isNSAutoreleasePool(interT->getDecl()); |
| return false; |
| } |
| |
| static Expr *getEssential(Expr *E) { |
| return cast<Expr>(getEssential((Stmt*)E)); |
| } |
| static Stmt *getEssential(Stmt *S) { |
| if (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(S)) |
| S = EWC->getSubExpr(); |
| if (Expr *E = dyn_cast<Expr>(S)) |
| S = E->IgnoreParenCasts(); |
| return S; |
| } |
| |
| Stmt *Body; |
| MigrationPass &Pass; |
| |
| IdentifierInfo *PoolII; |
| Selector DrainSel; |
| |
| struct PoolVarInfo { |
| DeclStmt *Dcl; |
| ExprSet Refs; |
| SmallVector<PoolScope, 2> Scopes; |
| |
| PoolVarInfo() : Dcl(0) { } |
| }; |
| |
| std::map<VarDecl *, PoolVarInfo> PoolVars; |
| }; |
| |
| } // anonymous namespace |
| |
| void trans::rewriteAutoreleasePool(MigrationPass &pass) { |
| BodyTransform<AutoreleasePoolRewriter> trans(pass); |
| trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl()); |
| } |
